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         location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1541
1542         location->set_auto_loop (true, this);
1543
1544         if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
1545                 // set all tracks to use internal looping
1546                 boost::shared_ptr<RouteList> rl = routes.reader ();
1547                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1548                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1549                         if (tr && !tr->hidden()) {
1550                                 tr->set_loop (location);
1551                         }
1552                 }
1553         }
1554
1555         /* take care of our stuff first */
1556
1557         auto_loop_changed (location);
1558
1559         /* now tell everyone else */
1560
1561         auto_loop_location_changed (location);
1562 }
1563
1564 void
1565 Session::update_loop (Location*)
1566 {
1567         set_dirty ();
1568 }
1569
1570 void
1571 Session::update_marks (Location*)
1572 {
1573         set_dirty ();
1574 }
1575
1576 void
1577 Session::update_skips (Location* loc, bool consolidate)
1578 {
1579         if (_ignore_skips_updates) {
1580                 return;
1581         }
1582
1583         Locations::LocationList skips;
1584
1585         if (consolidate) {
1586                 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1587                 consolidate_skips (loc);
1588         }
1589
1590         sync_locations_to_skips ();
1591
1592         set_dirty ();
1593 }
1594
1595 void
1596 Session::consolidate_skips (Location* loc)
1597 {
1598         Locations::LocationList all_locations = _locations->list ();
1599
1600         for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1601
1602                 if (!(*l)->is_skip ()) {
1603                         ++l;
1604                         continue;
1605                 }
1606
1607                 /* don't test against self */
1608
1609                 if (*l == loc) {
1610                         ++l;
1611                         continue;
1612                 }
1613
1614                 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1615                 case Evoral::OverlapInternal:
1616                 case Evoral::OverlapExternal:
1617                 case Evoral::OverlapStart:
1618                 case Evoral::OverlapEnd:
1619                         /* adjust new location to cover existing one */
1620                         loc->set_start (min (loc->start(), (*l)->start()));
1621                         loc->set_end (max (loc->end(), (*l)->end()));
1622                         /* we don't need this one any more */
1623                         _locations->remove (*l);
1624                         /* the location has been deleted, so remove reference to it in our local list */
1625                         l = all_locations.erase (l);
1626                         break;
1627
1628                 case Evoral::OverlapNone:
1629                         ++l;
1630                         break;
1631                 }
1632         }
1633 }
1634
1635 void
1636 Session::sync_locations_to_skips ()
1637 {
1638         /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1639          * Session::_sync_locations_to_skips() from the audioengine thread.
1640          */
1641         clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1642 }
1643
1644 void
1645 Session::_sync_locations_to_skips ()
1646 {
1647         /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1648
1649         Locations::LocationList const & locs (_locations->list());
1650
1651         for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1652
1653                 Location* location = *i;
1654
1655                 if (location->is_skip() && location->is_skipping()) {
1656                         SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1657                         queue_event (ev);
1658                 }
1659         }
1660 }
1661
1662
1663 void
1664 Session::location_added (Location *location)
1665 {
1666         if (location->is_auto_punch()) {
1667                 set_auto_punch_location (location);
1668         }
1669
1670         if (location->is_auto_loop()) {
1671                 set_auto_loop_location (location);
1672         }
1673
1674         if (location->is_session_range()) {
1675                 /* no need for any signal handling or event setting with the session range,
1676                    because we keep a direct reference to it and use its start/end directly.
1677                 */
1678                 _session_range_location = location;
1679         }
1680
1681         if (location->is_mark()) {
1682                 /* listen for per-location signals that require us to do any * global updates for marks */
1683
1684                 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1685                 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1686                 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1687                 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1688         }
1689
1690         if (location->is_skip()) {
1691                 /* listen for per-location signals that require us to update skip-locate events */
1692
1693                 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1694                 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1695                 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1696                 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
1697
1698                 update_skips (location, true);
1699         }
1700
1701         set_dirty ();
1702 }
1703
1704 void
1705 Session::location_removed (Location *location)
1706 {
1707         if (location->is_auto_loop()) {
1708                 set_auto_loop_location (0);
1709                 set_track_loop (false);
1710         }
1711
1712         if (location->is_auto_punch()) {
1713                 set_auto_punch_location (0);
1714         }
1715
1716         if (location->is_session_range()) {
1717                 /* this is never supposed to happen */
1718                 error << _("programming error: session range removed!") << endl;
1719         }
1720
1721         if (location->is_skip()) {
1722
1723                 update_skips (location, false);
1724         }
1725
1726         set_dirty ();
1727 }
1728
1729 void
1730 Session::locations_changed ()
1731 {
1732         _locations->apply (*this, &Session::_locations_changed);
1733 }
1734
1735 void
1736 Session::_locations_changed (const Locations::LocationList& locations)
1737 {
1738         /* There was some mass-change in the Locations object.
1739
1740            We might be re-adding a location here but it doesn't actually matter
1741            for all the locations that the Session takes an interest in.
1742         */
1743
1744         {
1745                 PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
1746                 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1747                         location_added (*i);
1748                 }
1749         }
1750
1751         update_skips (NULL, false);
1752 }
1753
1754 void
1755 Session::enable_record ()
1756 {
1757         if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1758                 /* no recording at anything except normal speed */
1759                 return;
1760         }
1761
1762         while (1) {
1763                 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1764
1765                 if (rs == Recording) {
1766                         break;
1767                 }
1768
1769                 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1770
1771                         _last_record_location = _transport_frame;
1772                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1773
1774                         if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1775                                 set_track_monitor_input_status (true);
1776                         }
1777
1778                         RecordStateChanged ();
1779                         break;
1780                 }
1781         }
1782 }
1783
1784 void
1785 Session::disable_record (bool rt_context, bool force)
1786 {
1787         RecordState rs;
1788
1789         if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1790
1791                 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1792                         g_atomic_int_set (&_record_status, Disabled);
1793                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1794                 } else {
1795                         if (rs == Recording) {
1796                                 g_atomic_int_set (&_record_status, Enabled);
1797                         }
1798                 }
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                 if (!rt_context) {
1807                         remove_pending_capture_state ();
1808                 }
1809         }
1810 }
1811
1812 void
1813 Session::step_back_from_record ()
1814 {
1815         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1816
1817                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1818                         set_track_monitor_input_status (false);
1819                 }
1820
1821                 RecordStateChanged (); /* emit signal */
1822         }
1823 }
1824
1825 void
1826 Session::maybe_enable_record ()
1827 {
1828         if (_step_editors > 0) {
1829                 return;
1830         }
1831
1832         g_atomic_int_set (&_record_status, Enabled);
1833
1834         /* This function is currently called from somewhere other than an RT thread.
1835            This save_state() call therefore doesn't impact anything.  Doing it here
1836            means that we save pending state of which sources the next record will use,
1837            which gives us some chance of recovering from a crash during the record.
1838         */
1839
1840         save_state ("", true);
1841
1842         if (_transport_speed) {
1843                 if (!config.get_punch_in()) {
1844                         enable_record ();
1845                 }
1846         } else {
1847                 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1848                 RecordStateChanged (); /* EMIT SIGNAL */
1849         }
1850
1851         set_dirty();
1852 }
1853
1854 framepos_t
1855 Session::audible_frame () const
1856 {
1857         framepos_t ret;
1858         framepos_t tf;
1859         framecnt_t offset;
1860
1861         offset = worst_playback_latency ();
1862
1863         if (synced_to_engine()) {
1864                 /* Note: this is basically just sync-to-JACK */
1865                 tf = _engine.transport_frame();
1866         } else {
1867                 tf = _transport_frame;
1868         }
1869
1870         ret = tf;
1871
1872         if (!non_realtime_work_pending()) {
1873
1874                 /* MOVING */
1875
1876                 /* Check to see if we have passed the first guaranteed
1877                    audible frame past our last start position. if not,
1878                    return that last start point because in terms
1879                    of audible frames, we have not moved yet.
1880
1881                    `Start position' in this context means the time we last
1882                    either started, located, or changed transport direction.
1883                 */
1884
1885                 if (_transport_speed > 0.0f) {
1886
1887                         if (!play_loop || !have_looped) {
1888                                 if (tf < _last_roll_or_reversal_location + offset) {
1889                                         return _last_roll_or_reversal_location;
1890                                 }
1891                         }
1892
1893
1894                         /* forwards */
1895                         ret -= offset;
1896
1897                 } else if (_transport_speed < 0.0f) {
1898
1899                         /* XXX wot? no backward looping? */
1900
1901                         if (tf > _last_roll_or_reversal_location - offset) {
1902                                 return _last_roll_or_reversal_location;
1903                         } else {
1904                                 /* backwards */
1905                                 ret += offset;
1906                         }
1907                 }
1908         }
1909
1910         return ret;
1911 }
1912
1913 void
1914 Session::set_frame_rate (framecnt_t frames_per_second)
1915 {
1916         /** \fn void Session::set_frame_size(framecnt_t)
1917                 the AudioEngine object that calls this guarantees
1918                 that it will not be called while we are also in
1919                 ::process(). Its fine to do things that block
1920                 here.
1921         */
1922
1923         _base_frame_rate = frames_per_second;
1924         _nominal_frame_rate = frames_per_second;
1925
1926         sync_time_vars();
1927
1928         clear_clicks ();
1929
1930         // XXX we need some equivalent to this, somehow
1931         // SndFileSource::setup_standard_crossfades (frames_per_second);
1932
1933         set_dirty();
1934
1935         /* XXX need to reset/reinstantiate all LADSPA plugins */
1936 }
1937
1938 void
1939 Session::set_block_size (pframes_t nframes)
1940 {
1941         /* the AudioEngine guarantees
1942            that it will not be called while we are also in
1943            ::process(). It is therefore fine to do things that block
1944            here.
1945         */
1946
1947         {
1948                 current_block_size = nframes;
1949
1950                 ensure_buffers ();
1951
1952                 boost::shared_ptr<RouteList> r = routes.reader ();
1953
1954                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1955                         (*i)->set_block_size (nframes);
1956                 }
1957
1958                 boost::shared_ptr<RouteList> rl = routes.reader ();
1959                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1960                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1961                         if (tr) {
1962                                 tr->set_block_size (nframes);
1963                         }
1964                 }
1965
1966                 set_worst_io_latencies ();
1967         }
1968 }
1969
1970
1971 static void
1972 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1973 {
1974         boost::shared_ptr<Route> r2;
1975
1976         if (r1->feeds (rbase) && rbase->feeds (r1)) {
1977                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1978                 return;
1979         }
1980
1981         /* make a copy of the existing list of routes that feed r1 */
1982
1983         Route::FedBy existing (r1->fed_by());
1984
1985         /* for each route that feeds r1, recurse, marking it as feeding
1986            rbase as well.
1987         */
1988
1989         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1990                 if (!(r2 = i->r.lock ())) {
1991                         /* (*i) went away, ignore it */
1992                         continue;
1993                 }
1994
1995                 /* r2 is a route that feeds r1 which somehow feeds base. mark
1996                    base as being fed by r2
1997                 */
1998
1999                 rbase->add_fed_by (r2, i->sends_only);
2000
2001                 if (r2 != rbase) {
2002
2003                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2004                            stop here.
2005                         */
2006
2007                         if (r1->feeds (r2) && r2->feeds (r1)) {
2008                                 continue;
2009                         }
2010
2011                         /* now recurse, so that we can mark base as being fed by
2012                            all routes that feed r2
2013                         */
2014
2015                         trace_terminal (r2, rbase);
2016                 }
2017
2018         }
2019 }
2020
2021 void
2022 Session::resort_routes ()
2023 {
2024         /* don't do anything here with signals emitted
2025            by Routes during initial setup or while we
2026            are being destroyed.
2027         */
2028
2029         if (_state_of_the_state & (InitialConnecting | Deletion)) {
2030                 return;
2031         }
2032
2033         {
2034                 RCUWriter<RouteList> writer (routes);
2035                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2036                 resort_routes_using (r);
2037                 /* writer goes out of scope and forces update */
2038         }
2039
2040 #ifndef NDEBUG
2041         boost::shared_ptr<RouteList> rl = routes.reader ();
2042         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2043                 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2044
2045                 const Route::FedBy& fb ((*i)->fed_by());
2046
2047                 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2048                         boost::shared_ptr<Route> sf = f->r.lock();
2049                         if (sf) {
2050                                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2051                         }
2052                 }
2053         }
2054 #endif
2055
2056 }
2057
2058 /** This is called whenever we need to rebuild the graph of how we will process
2059  *  routes.
2060  *  @param r List of routes, in any order.
2061  */
2062
2063 void
2064 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2065 {
2066         /* We are going to build a directed graph of our routes;
2067            this is where the edges of that graph are put.
2068         */
2069
2070         GraphEdges edges;
2071
2072         /* Go through all routes doing two things:
2073          *
2074          * 1. Collect the edges of the route graph.  Each of these edges
2075          *    is a pair of routes, one of which directly feeds the other
2076          *    either by a JACK connection or by an internal send.
2077          *
2078          * 2. Begin the process of making routes aware of which other
2079          *    routes directly or indirectly feed them.  This information
2080          *    is used by the solo code.
2081          */
2082
2083         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2084
2085                 /* Clear out the route's list of direct or indirect feeds */
2086                 (*i)->clear_fed_by ();
2087
2088                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2089
2090                         bool via_sends_only;
2091
2092                         /* See if this *j feeds *i according to the current state of the JACK
2093                            connections and internal sends.
2094                         */
2095                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2096                                 /* add the edge to the graph (part #1) */
2097                                 edges.add (*j, *i, via_sends_only);
2098                                 /* tell the route (for part #2) */
2099                                 (*i)->add_fed_by (*j, via_sends_only);
2100                         }
2101                 }
2102         }
2103
2104         /* Attempt a topological sort of the route graph */
2105         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2106
2107         if (sorted_routes) {
2108                 /* We got a satisfactory topological sort, so there is no feedback;
2109                    use this new graph.
2110
2111                    Note: the process graph rechain does not require a
2112                    topologically-sorted list, but hey ho.
2113                 */
2114                 if (_process_graph) {
2115                         _process_graph->rechain (sorted_routes, edges);
2116                 }
2117
2118                 _current_route_graph = edges;
2119
2120                 /* Complete the building of the routes' lists of what directly
2121                    or indirectly feeds them.
2122                 */
2123                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2124                         trace_terminal (*i, *i);
2125                 }
2126
2127                 *r = *sorted_routes;
2128
2129 #ifndef NDEBUG
2130                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2131                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2132                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
2133                                                                    (*i)->name(), (*i)->order_key ()));
2134                 }
2135 #endif
2136
2137                 SuccessfulGraphSort (); /* EMIT SIGNAL */
2138
2139         } else {
2140                 /* The topological sort failed, so we have a problem.  Tell everyone
2141                    and stick to the old graph; this will continue to be processed, so
2142                    until the feedback is fixed, what is played back will not quite
2143                    reflect what is actually connected.  Note also that we do not
2144                    do trace_terminal here, as it would fail due to an endless recursion,
2145                    so the solo code will think that everything is still connected
2146                    as it was before.
2147                 */
2148
2149                 FeedbackDetected (); /* EMIT SIGNAL */
2150         }
2151
2152 }
2153
2154 /** Find a route name starting with \a base, maybe followed by the
2155  *  lowest \a id.  \a id will always be added if \a definitely_add_number
2156  *  is true on entry; otherwise it will only be added if required
2157  *  to make the name unique.
2158  *
2159  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2160  *  The available route name with the lowest ID will be used, and \a id
2161  *  will be set to the ID.
2162  *
2163  *  \return false if a route name could not be found, and \a track_name
2164  *  and \a id do not reflect a free route name.
2165  */
2166 bool
2167 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
2168 {
2169         if (!definitely_add_number && route_by_name (base) == 0) {
2170                 /* juse use the base */
2171                 snprintf (name, name_len, "%s", base.c_str());
2172                 return true;
2173         }
2174
2175         do {
2176                 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
2177
2178                 if (route_by_name (name) == 0) {
2179                         return true;
2180                 }
2181
2182                 ++id;
2183
2184         } while (id < (UINT_MAX-1));
2185
2186         return false;
2187 }
2188
2189 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2190 void
2191 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2192 {
2193         in  = ChanCount::ZERO;
2194         out = ChanCount::ZERO;
2195
2196         boost::shared_ptr<RouteList> r = routes.reader ();
2197
2198         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2199                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2200                 if (tr && !tr->is_auditioner()) {
2201                         in  += tr->n_inputs();
2202                         out += tr->n_outputs();
2203                 }
2204         }
2205 }
2206
2207 /** Caller must not hold process lock
2208  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
2209  *  @param instrument plugin info for the instrument to insert pre-fader, if any
2210  */
2211 list<boost::shared_ptr<MidiTrack> >
2212 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
2213                          TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
2214 {
2215         char track_name[32];
2216         uint32_t track_id = 0;
2217         string port;
2218         RouteList new_routes;
2219         list<boost::shared_ptr<MidiTrack> > ret;
2220
2221         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
2222
2223         while (how_many) {
2224                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2225                         error << "cannot find name for new midi track" << endmsg;
2226                         goto failed;
2227                 }
2228
2229                 boost::shared_ptr<MidiTrack> track;
2230
2231                 try {
2232                         track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
2233
2234                         if (track->init ()) {
2235                                 goto failed;
2236                         }
2237
2238                         track->use_new_diskstream();
2239
2240 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2241                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2242 #endif
2243                         {
2244                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2245                                 if (track->input()->ensure_io (input, false, this)) {
2246                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2247                                         goto failed;
2248                                 }
2249
2250                                 if (track->output()->ensure_io (output, false, this)) {
2251                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2252                                         goto failed;
2253                                 }
2254                         }
2255
2256                         track->non_realtime_input_change();
2257
2258                         if (route_group) {
2259                                 route_group->add (track);
2260                         }
2261
2262                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2263
2264                         if (Config->get_remote_model() == UserOrdered) {
2265                                 track->set_remote_control_id (next_control_id());
2266                         }
2267
2268                         new_routes.push_back (track);
2269                         ret.push_back (track);
2270
2271                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2272                 }
2273
2274                 catch (failed_constructor &err) {
2275                         error << _("Session: could not create new midi track.") << endmsg;
2276                         goto failed;
2277                 }
2278
2279                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2280
2281                         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;
2282                         goto failed;
2283                 }
2284
2285                 --how_many;
2286         }
2287
2288   failed:
2289         if (!new_routes.empty()) {
2290                 StateProtector sp (this);
2291                 if (Profile->get_trx()) {
2292                         add_routes (new_routes, false, false, false);
2293                 } else {
2294                         add_routes (new_routes, true, true, false);
2295                 }
2296
2297                 if (instrument) {
2298                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2299                                 PluginPtr plugin = instrument->load (*this);
2300                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2301                                 (*r)->add_processor (p, PreFader);
2302
2303                         }
2304                 }
2305         }
2306
2307         return ret;
2308 }
2309
2310 void
2311 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2312 {
2313         boost::shared_ptr<Route> midi_track (wmt.lock());
2314
2315         if (!midi_track) {
2316                 return;
2317         }
2318
2319         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2320
2321                 if (change.after.n_audio() <= change.before.n_audio()) {
2322                         return;
2323                 }
2324
2325                 /* new audio ports: make sure the audio goes somewhere useful,
2326                    unless the user has no-auto-connect selected.
2327
2328                    The existing ChanCounts don't matter for this call as they are only
2329                    to do with matching input and output indices, and we are only changing
2330                    outputs here.
2331                 */
2332
2333                 ChanCount dummy;
2334
2335                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
2336         }
2337 }
2338
2339 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
2340  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
2341  *  @param output_start As \a input_start, but for outputs.
2342  */
2343 void
2344 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
2345                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
2346 {
2347         if (!IO::connecting_legal) {
2348                 return;
2349         }
2350
2351         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2352
2353         if (with_lock) {
2354                 lm.acquire ();
2355         }
2356
2357         /* If both inputs and outputs are auto-connected to physical ports,
2358            use the max of input and output offsets to ensure auto-connected
2359            port numbers always match up (e.g. the first audio input and the
2360            first audio output of the route will have the same physical
2361            port number).  Otherwise just use the lowest input or output
2362            offset possible.
2363         */
2364
2365         DEBUG_TRACE (DEBUG::Graph,
2366                      string_compose("Auto-connect: existing in = %1 out = %2\n",
2367                                     existing_inputs, existing_outputs));
2368
2369         const bool in_out_physical =
2370                 (Config->get_input_auto_connect() & AutoConnectPhysical)
2371                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
2372                 && connect_inputs;
2373
2374         const ChanCount in_offset = in_out_physical
2375                 ? ChanCount::max(existing_inputs, existing_outputs)
2376                 : existing_inputs;
2377
2378         const ChanCount out_offset = in_out_physical
2379                 ? ChanCount::max(existing_inputs, existing_outputs)
2380                 : existing_outputs;
2381
2382         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2383                 vector<string> physinputs;
2384                 vector<string> physoutputs;
2385
2386                 _engine.get_physical_outputs (*t, physoutputs);
2387                 _engine.get_physical_inputs (*t, physinputs);
2388
2389                 if (!physinputs.empty() && connect_inputs) {
2390                         uint32_t nphysical_in = physinputs.size();
2391
2392                         DEBUG_TRACE (DEBUG::Graph,
2393                                      string_compose("There are %1 physical inputs of type %2\n",
2394                                                     nphysical_in, *t));
2395
2396                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
2397                                 string port;
2398
2399                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
2400                                         DEBUG_TRACE (DEBUG::Graph,
2401                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
2402                                                                     in_offset.get(*t), i, nphysical_in,
2403                                                                     (in_offset.get(*t) + i) % nphysical_in));
2404                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
2405                                 }
2406
2407                                 DEBUG_TRACE (DEBUG::Graph,
2408                                              string_compose("Connect route %1 IN to %2\n",
2409                                                             route->name(), port));
2410
2411                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
2412                                         break;
2413                                 }
2414
2415                                 ChanCount one_added (*t, 1);
2416                                 existing_inputs += one_added;
2417                         }
2418                 }
2419
2420                 if (!physoutputs.empty()) {
2421                         uint32_t nphysical_out = physoutputs.size();
2422                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
2423                                 string port;
2424
2425                                 /* Waves Tracks:
2426                                  * do not create new connections if we reached the limit of physical outputs
2427                                  * in Multi Out mode
2428                                  */
2429
2430                                 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
2431                                     ARDOUR::Profile->get_trx () &&
2432                                     existing_outputs.get(*t) == nphysical_out ) {
2433                                         break;
2434                                 }
2435
2436                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
2437                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
2438                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
2439                                         /* master bus is audio only */
2440                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
2441                                                 port = _master_out->input()->ports().port(*t,
2442                                                                 i % _master_out->input()->n_ports().get(*t))->name();
2443                                         }
2444                                 }
2445
2446                                 DEBUG_TRACE (DEBUG::Graph,
2447                                              string_compose("Connect route %1 OUT to %2\n",
2448                                                             route->name(), port));
2449
2450                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2451                                         break;
2452                                 }
2453
2454                                 ChanCount one_added (*t, 1);
2455                                 existing_outputs += one_added;
2456                         }
2457                 }
2458         }
2459 }
2460
2461 #ifdef USE_TRACKS_CODE_FEATURES
2462
2463 static bool
2464 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2465 {
2466         return route1->remote_control_id() < route2->remote_control_id();
2467 }
2468
2469 void
2470 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2471 {
2472         // it is not allowed to perform connection
2473         if (!IO::connecting_legal) {
2474                 return;
2475         }
2476
2477         // if we are deleting routes we will call this once at the end
2478         if (_route_deletion_in_progress) {
2479                 return;
2480         }
2481
2482         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2483
2484         if (withLock) {
2485                 lm.acquire ();
2486         }
2487
2488         // We need to disconnect the route's inputs and outputs first
2489         // basing on autoconnect configuration
2490         bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2491         bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2492
2493         ChanCount existing_inputs;
2494         ChanCount existing_outputs;
2495         count_existing_track_channels (existing_inputs, existing_outputs);
2496
2497         //ChanCount inputs = ChanCount::ZERO;
2498         //ChanCount outputs = ChanCount::ZERO;
2499
2500         RouteList existing_routes = *routes.reader ();
2501         existing_routes.sort (compare_routes_by_remote_id);
2502
2503         {
2504                 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2505
2506                 vector<string> physinputs;
2507                 vector<string> physoutputs;
2508
2509                 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2510                 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2511
2512                 uint32_t input_n = 0;
2513                 uint32_t output_n = 0;
2514                 RouteList::iterator rIter = existing_routes.begin();
2515                 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2516                 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2517                 for (; rIter != existing_routes.end(); ++rIter) {
2518                         if (*rIter == _master_out || *rIter == _monitor_out ) {
2519                                 continue;
2520                         }
2521
2522                         if (current_output_auto_connection == AutoConnectPhysical) {
2523                                 (*rIter)->amp()->deactivate();
2524                         } else if (current_output_auto_connection == AutoConnectMaster) {
2525                                 (*rIter)->amp()->activate();
2526                         }
2527
2528                         if (reconnectIputs) {
2529                                 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2530
2531                                 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2532
2533                                         if (current_input_auto_connection & AutoConnectPhysical) {
2534
2535                                                 if ( input_n == physinputs.size() ) {
2536                                                         break;
2537                                                 }
2538
2539                                                 string port = physinputs[input_n];
2540
2541                                                 if (port.empty() ) {
2542                                                         error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2543                                                 }
2544
2545                                                 //GZ: check this; could be heavy
2546                                                 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2547                                                 ++input_n;
2548                                         }
2549                                 }
2550                         }
2551
2552                         if (reconnectOutputs) {
2553
2554                                 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2555                                 if (current_output_auto_connection & AutoConnectPhysical) {
2556
2557                                         //GZ: check this; could be heavy
2558                                         (*rIter)->output()->disconnect (this);
2559                                         size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2560
2561                                         //GZ: check this; could be heavy
2562                                         (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2563
2564                                 } else if (current_output_auto_connection & AutoConnectMaster){
2565
2566                                         if (!reconnect_master) {
2567                                                 continue;
2568                                         }
2569
2570                                         //GZ: check this; could be heavy
2571                                         (*rIter)->output()->disconnect (this);
2572
2573                                         if (_master_out) {
2574                                                 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2575                                                 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2576                                         } else {
2577                                                 error << error << "Master bus is not available" << endmsg;
2578                                                 break;
2579                                         }
2580                                 }
2581
2582                                 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2583                                         if (current_output_auto_connection & AutoConnectPhysical) {
2584
2585                                                 if ( output_n == physoutputs.size() ) {
2586                                                         break;
2587                                                 }
2588
2589                                                 string port = physoutputs[output_n];
2590
2591                                                 if (port.empty() ) {
2592                                                         error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2593                                                 }
2594
2595                                                 //GZ: check this; could be heavy
2596                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2597                                                 ++output_n;
2598
2599                                         } else if (current_output_auto_connection & AutoConnectMaster) {
2600
2601                                                 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2602                                                         break;
2603                                                 }
2604
2605                                                 // connect to master bus
2606                                                 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2607
2608                                                 if (port.empty() ) {
2609                                                         error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2610                                                 }
2611
2612
2613                                                 //GZ: check this; could be heavy
2614                                                 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2615
2616                                         }
2617                                 }
2618                         }
2619
2620                         //auto_connect_route (*rIter, inputs, outputs, false, reconnectIputs);
2621                 }
2622
2623                 _master_out->output()->disconnect (this);
2624                 auto_connect_master_bus ();
2625         }
2626
2627         graph_reordered ();
2628
2629         session_routes_reconnected (); /* EMIT SIGNAL */
2630 }
2631
2632 void
2633 Session::reconnect_midi_scene_ports(bool inputs)
2634 {
2635     if (inputs ) {
2636
2637         boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2638         if (scene_in_ptr) {
2639             scene_in_ptr->disconnect_all ();
2640
2641             std::vector<EngineStateController::MidiPortState> midi_port_states;
2642             EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2643
2644             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2645
2646             for (; state_iter != midi_port_states.end(); ++state_iter) {
2647                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2648                     scene_in_ptr->connect (state_iter->name);
2649                 }
2650             }
2651         }
2652
2653     } else {
2654
2655         boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2656
2657         if (scene_out_ptr ) {
2658             scene_out_ptr->disconnect_all ();
2659
2660             std::vector<EngineStateController::MidiPortState> midi_port_states;
2661             EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2662
2663             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2664
2665             for (; state_iter != midi_port_states.end(); ++state_iter) {
2666                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2667                     scene_out_ptr->connect (state_iter->name);
2668                 }
2669             }
2670         }
2671     }
2672 }
2673
2674 void
2675 Session::reconnect_mtc_ports()
2676 {
2677 #if 0
2678         boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
2679
2680         if (mtc_in_ptr) {
2681                 mtc_in_ptr->disconnect_all ();
2682
2683                 std::vector<EngineStateController::MidiPortState> midi_port_states;
2684                 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2685
2686                 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2687
2688                 for (; state_iter != midi_port_states.end(); ++state_iter) {
2689                         if (state_iter->available && state_iter->mtc_in) {
2690                                 mtc_in_ptr->connect (state_iter->name);
2691                         }
2692                 }
2693
2694                 if (!_midi_ports->mtc_input_port ()->connected () &&
2695                     config.get_external_sync () &&
2696                     (Config->get_sync_source () == MTC) ) {
2697                         config.set_external_sync (false);
2698                 }
2699                 if ( ARDOUR::Profile->get_trx () ) {
2700                         // Tracks need this signal to update timecode_source_dropdown
2701                         MtcOrLtcInputPortChanged (); //emit signal
2702                 }
2703         }
2704 #endif
2705 }
2706
2707 void
2708 Session::reconnect_mmc_ports(bool inputs)
2709 {
2710         if (inputs ) { // get all enabled midi input ports
2711
2712                 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
2713                 if (mmc_in_ptr) {
2714                         mmc_in_ptr->disconnect_all ();
2715                         std::vector<std::string> enabled_midi_inputs;
2716                         EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
2717
2718                         std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
2719
2720                         for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
2721                                 mmc_in_ptr->connect (*port_iter);
2722                         }
2723
2724                 }
2725         } else { // get all enabled midi output ports
2726
2727                 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
2728                 if (mmc_out_ptr ) {
2729                         mmc_out_ptr->disconnect_all ();
2730                         std::vector<std::string> enabled_midi_outputs;
2731                         EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
2732
2733                         std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
2734
2735                         for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
2736                                 mmc_out_ptr->connect (*port_iter);
2737                         }
2738                 }
2739         }
2740 }
2741
2742 #endif
2743
2744 /** Caller must not hold process lock
2745  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2746  */
2747 list< boost::shared_ptr<AudioTrack> >
2748 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2749                           uint32_t how_many, string name_template)
2750 {
2751         char track_name[32];
2752         uint32_t track_id = 0;
2753         string port;
2754         RouteList new_routes;
2755         list<boost::shared_ptr<AudioTrack> > ret;
2756
2757         string name_pattern;
2758
2759         if (Profile->get_trx() ) {
2760                 name_pattern = "Track ";
2761         } else {
2762                 name_pattern = "Audio ";
2763         }
2764
2765         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _(name_pattern.c_str() );
2766
2767         while (how_many) {
2768
2769                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2770                         error << "cannot find name for new audio track" << endmsg;
2771                         goto failed;
2772                 }
2773
2774                 boost::shared_ptr<AudioTrack> track;
2775
2776                 try {
2777                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2778
2779                         if (track->init ()) {
2780                                 goto failed;
2781                         }
2782
2783                         if (ARDOUR::Profile->get_trx ()) {
2784                                 // TRACKS considers it's not a USE CASE, it's
2785                                 // a piece of behavior of the session model:
2786                                 //
2787                                 // Gain for a newly created route depends on
2788                                 // the current output_auto_connect mode:
2789                                 //
2790                                 //  0 for Stereo Out mode
2791                                 //  0 Multi Out mode
2792                                 if (Config->get_output_auto_connect() & AutoConnectMaster) {
2793                                         track->set_gain (dB_to_coefficient (0), 0);
2794                                 }
2795                         }
2796
2797                         track->use_new_diskstream();
2798
2799 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2800                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2801 #endif
2802                         {
2803                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2804
2805                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2806                                         error << string_compose (
2807                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2808                                                 input_channels, output_channels)
2809                                               << endmsg;
2810                                         goto failed;
2811                                 }
2812
2813                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2814                                         error << string_compose (
2815                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2816                                                 input_channels, output_channels)
2817                                               << endmsg;
2818                                         goto failed;
2819                                 }
2820                         }
2821
2822                         if (route_group) {
2823                                 route_group->add (track);
2824                         }
2825
2826                         track->non_realtime_input_change();
2827
2828                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2829                         if (Config->get_remote_model() == UserOrdered) {
2830                                 track->set_remote_control_id (next_control_id());
2831                         }
2832
2833                         new_routes.push_back (track);
2834                         ret.push_back (track);
2835
2836                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2837                 }
2838
2839                 catch (failed_constructor &err) {
2840                         error << _("Session: could not create new audio track.") << endmsg;
2841                         goto failed;
2842                 }
2843
2844                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2845
2846                         error << pfe.what() << endmsg;
2847                         goto failed;
2848                 }
2849
2850                 --how_many;
2851         }
2852
2853   failed:
2854         if (!new_routes.empty()) {
2855                 StateProtector sp (this);
2856                 if (Profile->get_trx()) {
2857                         add_routes (new_routes, false, false, false);
2858                 } else {
2859                         add_routes (new_routes, true, true, false);
2860                 }
2861         }
2862
2863         return ret;
2864 }
2865
2866 /** Caller must not hold process lock.
2867  *  @param name_template string to use for the start of the name, or "" to use "Bus".
2868  */
2869 RouteList
2870 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2871 {
2872         char bus_name[32];
2873         uint32_t bus_id = 0;
2874         string port;
2875         RouteList ret;
2876
2877         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2878
2879         while (how_many) {
2880                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2881                         error << "cannot find name for new audio bus" << endmsg;
2882                         goto failure;
2883                 }
2884
2885                 try {
2886                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2887
2888                         if (bus->init ()) {
2889                                 goto failure;
2890                         }
2891
2892 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2893                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2894 #endif
2895                         {
2896                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2897
2898                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2899                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2900                                                                  input_channels, output_channels)
2901                                               << endmsg;
2902                                         goto failure;
2903                                 }
2904
2905
2906                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2907                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2908                                                                  input_channels, output_channels)
2909                                               << endmsg;
2910                                         goto failure;
2911                                 }
2912                         }
2913
2914                         if (route_group) {
2915                                 route_group->add (bus);
2916                         }
2917                         if (Config->get_remote_model() == UserOrdered) {
2918                                 bus->set_remote_control_id (next_control_id());
2919                         }
2920
2921                         bus->add_internal_return ();
2922
2923                         ret.push_back (bus);
2924
2925                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2926
2927                         ARDOUR::GUIIdle ();
2928                 }
2929
2930
2931                 catch (failed_constructor &err) {
2932                         error << _("Session: could not create new audio route.") << endmsg;
2933                         goto failure;
2934                 }
2935
2936                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2937                         error << pfe.what() << endmsg;
2938                         goto failure;
2939                 }
2940
2941
2942                 --how_many;
2943         }
2944
2945   failure:
2946         if (!ret.empty()) {
2947                 StateProtector sp (this);
2948                 if (Profile->get_trx()) {
2949                         add_routes (ret, false, false, false);
2950                 } else {
2951                         add_routes (ret, false, true, true); // autoconnect // outputs only
2952                 }
2953         }
2954
2955         return ret;
2956
2957 }
2958
2959 RouteList
2960 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2961 {
2962         RouteList ret;
2963         uint32_t control_id;
2964         XMLTree tree;
2965         uint32_t number = 0;
2966         const uint32_t being_added = how_many;
2967
2968         if (!tree.read (template_path.c_str())) {
2969                 return ret;
2970         }
2971
2972         XMLNode* node = tree.root();
2973
2974         IO::disable_connecting ();
2975
2976         control_id = next_control_id ();
2977
2978         while (how_many) {
2979
2980                 XMLNode node_copy (*node);
2981
2982                 /* Remove IDs of everything so that new ones are used */
2983                 node_copy.remove_property_recursively (X_("id"));
2984
2985                 try {
2986                         char name[32];
2987
2988                         if (!name_base.empty()) {
2989
2990                                 /* if we're adding more than one routes, force
2991                                  * all the names of the new routes to be
2992                                  * numbered, via the final parameter.
2993                                  */
2994
2995                                 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2996                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2997                                         /*NOTREACHDE*/
2998                                 }
2999
3000                         } else {
3001
3002                                 string const route_name  = node_copy.property(X_("name"))->value ();
3003
3004                                 /* generate a new name by adding a number to the end of the template name */
3005                                 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
3006                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3007                                         abort(); /*NOTREACHED*/
3008                                 }
3009                         }
3010
3011                         /* set this name in the XML description that we are about to use */
3012                         Route::set_name_in_state (node_copy, name);
3013
3014                         /* trim bitslots from listen sends so that new ones are used */
3015                         XMLNodeList children = node_copy.children ();
3016                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3017                                 if ((*i)->name() == X_("Processor")) {
3018                                         XMLProperty* role = (*i)->property (X_("role"));
3019                                         if (role && role->value() == X_("Listen")) {
3020                                                 (*i)->remove_property (X_("bitslot"));
3021                                         }
3022                                 }
3023                         }
3024
3025                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3026
3027                         if (route == 0) {
3028                                 error << _("Session: cannot create track/bus from template description") << endmsg;
3029                                 goto out;
3030                         }
3031
3032                         if (boost::dynamic_pointer_cast<Track>(route)) {
3033                                 /* force input/output change signals so that the new diskstream
3034                                    picks up the configuration of the route. During session
3035                                    loading this normally happens in a different way.
3036                                 */
3037
3038                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3039
3040                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3041                                 change.after = route->input()->n_ports();
3042                                 route->input()->changed (change, this);
3043                                 change.after = route->output()->n_ports();
3044                                 route->output()->changed (change, this);
3045                         }
3046
3047                         route->set_remote_control_id (control_id);
3048                         ++control_id;
3049
3050                         ret.push_back (route);
3051
3052                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3053                 }
3054
3055                 catch (failed_constructor &err) {
3056                         error << _("Session: could not create new route from template") << endmsg;
3057                         goto out;
3058                 }
3059
3060                 catch (AudioEngine::PortRegistrationFailure& pfe) {
3061                         error << pfe.what() << endmsg;
3062                         goto out;
3063                 }
3064
3065                 --how_many;
3066         }
3067
3068   out:
3069         if (!ret.empty()) {
3070                 StateProtector sp (this);
3071                 if (Profile->get_trx()) {
3072                         add_routes (ret, false, false, false);
3073                 } else {
3074                         add_routes (ret, true, true, false);
3075                 }
3076                 IO::enable_connecting ();
3077         }
3078
3079         return ret;
3080 }
3081
3082 void
3083 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
3084 {
3085         try {
3086                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3087                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
3088
3089         } catch (...) {
3090                 error << _("Adding new tracks/busses failed") << endmsg;
3091         }
3092
3093         graph_reordered ();
3094
3095         update_latency (true);
3096         update_latency (false);
3097
3098         set_dirty();
3099
3100         if (save) {
3101                 save_state (_current_snapshot_name);
3102         }
3103
3104         reassign_track_numbers();
3105
3106         update_route_record_state ();
3107
3108         RouteAdded (new_routes); /* EMIT SIGNAL */
3109 }
3110
3111 void
3112 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
3113 {
3114         ChanCount existing_inputs;
3115         ChanCount existing_outputs;
3116         uint32_t order = next_control_id();
3117
3118         if (_order_hint > -1) {
3119                 order = _order_hint;
3120                 _order_hint = -1;
3121         }
3122
3123         count_existing_track_channels (existing_inputs, existing_outputs);
3124
3125         {
3126                 RCUWriter<RouteList> writer (routes);
3127                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3128                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3129
3130                 /* if there is no control out and we're not in the middle of loading,
3131                    resort the graph here. if there is a control out, we will resort
3132                    toward the end of this method. if we are in the middle of loading,
3133                    we will resort when done.
3134                 */
3135
3136                 if (!_monitor_out && IO::connecting_legal) {
3137                         resort_routes_using (r);
3138                 }
3139         }
3140
3141         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3142
3143                 boost::weak_ptr<Route> wpr (*x);
3144                 boost::shared_ptr<Route> r (*x);
3145
3146                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
3147                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
3148                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
3149                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
3150                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3151                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3152
3153                 if (r->is_master()) {
3154                         _master_out = r;
3155                 }
3156
3157                 if (r->is_monitor()) {
3158                         _monitor_out = r;
3159                 }
3160
3161                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3162                 if (tr) {
3163                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3164                         track_playlist_changed (boost::weak_ptr<Track> (tr));
3165                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3166
3167                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3168                         if (mt) {
3169                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3170                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3171                         }
3172                 }
3173
3174
3175                 if (input_auto_connect || output_auto_connect) {
3176                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
3177                 }
3178
3179                 /* order keys are a GUI responsibility but we need to set up
3180                    reasonable defaults because they also affect the remote control
3181                    ID in most situations.
3182                 */
3183
3184                 if (!r->has_order_key ()) {
3185                         if (r->is_auditioner()) {
3186                                 /* use an arbitrarily high value */
3187                                 r->set_order_key (UINT_MAX);
3188                         } else {
3189                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
3190                                 r->set_order_key (order);
3191                                 order++;
3192                         }
3193                 }
3194
3195                 ARDOUR::GUIIdle ();
3196         }
3197
3198         if (_monitor_out && IO::connecting_legal) {
3199                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3200
3201                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3202                         if ((*x)->is_monitor()) {
3203                                 /* relax */
3204                         } else if ((*x)->is_master()) {
3205                                         /* relax */
3206                         } else {
3207                                 (*x)->enable_monitor_send ();
3208                         }
3209                 }
3210         }
3211 }
3212
3213 void
3214 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3215 {
3216         boost::shared_ptr<RouteList> r = routes.reader ();
3217         boost::shared_ptr<Send> s;
3218
3219         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3220                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3221                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO);
3222                 }
3223         }
3224 }
3225
3226 void
3227 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3228 {
3229         boost::shared_ptr<RouteList> r = routes.reader ();
3230         boost::shared_ptr<Send> s;
3231
3232         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3233                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3234                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY);
3235                 }
3236         }
3237 }
3238
3239 void
3240 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3241 {
3242         boost::shared_ptr<RouteList> r = routes.reader ();
3243         boost::shared_ptr<Send> s;
3244
3245         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3246                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3247                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
3248                 }
3249         }
3250 }
3251
3252 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3253 void
3254 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3255 {
3256         boost::shared_ptr<RouteList> r = routes.reader ();
3257         boost::shared_ptr<RouteList> t (new RouteList);
3258
3259         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3260                 /* no MIDI sends because there are no MIDI busses yet */
3261                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3262                         t->push_back (*i);
3263                 }
3264         }
3265
3266         add_internal_sends (dest, p, t);
3267 }
3268
3269 void
3270 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3271 {
3272         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3273                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3274         }
3275 }
3276
3277 void
3278 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3279 {
3280         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3281 }
3282
3283 void
3284 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3285 {
3286         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3287                 return;
3288         }
3289
3290         if (!dest->internal_return()) {
3291                 dest->add_internal_return ();
3292         }
3293
3294         sender->add_aux_send (dest, before);
3295
3296         graph_reordered ();
3297 }
3298
3299
3300 void
3301 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3302 {
3303         { // RCU Writer scope
3304                 RCUWriter<RouteList> writer (routes);
3305                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3306
3307
3308                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3309
3310                         if (*iter == _master_out) {
3311                                 continue;
3312                         }
3313
3314                         (*iter)->set_solo (false, this);
3315
3316                         rs->remove (*iter);
3317
3318                         /* deleting the master out seems like a dumb
3319                            idea, but its more of a UI policy issue
3320                            than our concern.
3321                         */
3322
3323                         if (*iter == _master_out) {
3324                                 _master_out = boost::shared_ptr<Route> ();
3325                         }
3326
3327                         if (*iter == _monitor_out) {
3328                                 _monitor_out.reset ();
3329                         }
3330
3331                         update_route_solo_state ();
3332
3333                         // We need to disconnect the route's inputs and outputs
3334
3335                         (*iter)->input()->disconnect (0);
3336                         (*iter)->output()->disconnect (0);
3337
3338                         /* if the route had internal sends sending to it, remove them */
3339                         if ((*iter)->internal_return()) {
3340
3341                                 boost::shared_ptr<RouteList> r = routes.reader ();
3342                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3343                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3344                                         if (s) {
3345                                                 (*i)->remove_processor (s);
3346                                         }
3347                                 }
3348                         }
3349
3350                         /* if the monitoring section had a pointer to this route, remove it */
3351                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3352                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3353                                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3354                                 (*iter)->remove_aux_or_listen (_monitor_out);
3355                         }
3356
3357                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3358                         if (mt && mt->step_editing()) {
3359                                 if (_step_editors > 0) {
3360                                         _step_editors--;
3361                                 }
3362                         }
3363
3364                         RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3365                 }
3366
3367                 /* writer goes out of scope, forces route list update */
3368
3369         } // end of RCU Writer scope
3370
3371         update_latency_compensation ();
3372         set_dirty();
3373
3374         /* Re-sort routes to remove the graph's current references to the one that is
3375          * going away, then flush old references out of the graph.
3376          * Wave Tracks: reconnect routes
3377          */
3378
3379 #ifdef USE_TRACKS_CODE_FEATURES
3380                 reconnect_existing_routes(true, false);
3381 #else
3382                 resort_routes ();
3383 #endif
3384
3385         if (_process_graph) {
3386                 _process_graph->clear_other_chain ();
3387         }
3388
3389         /* get rid of it from the dead wood collection in the route list manager */
3390         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3391
3392         routes.flush ();
3393
3394         /* try to cause everyone to drop their references
3395          * and unregister ports from the backend
3396          */
3397         PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3398
3399         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3400                 (*iter)->drop_references ();
3401         }
3402
3403         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3404
3405         /* save the new state of the world */
3406
3407         if (save_state (_current_snapshot_name)) {
3408                 save_history (_current_snapshot_name);
3409         }
3410
3411         reassign_track_numbers();
3412         update_route_record_state ();
3413 }
3414
3415 void
3416 Session::remove_route (boost::shared_ptr<Route> route)
3417 {
3418         boost::shared_ptr<RouteList> rl (new RouteList);
3419         rl->push_back (route);
3420         remove_routes (rl);
3421 }
3422
3423 void
3424 Session::route_mute_changed (void* /*src*/)
3425 {
3426         set_dirty ();
3427 }
3428
3429 void
3430 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3431 {
3432         boost::shared_ptr<Route> route = wpr.lock();
3433         if (!route) {
3434                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3435                 return;
3436         }
3437
3438         if (route->listening_via_monitor ()) {
3439
3440                 if (Config->get_exclusive_solo()) {
3441                         /* new listen: disable all other listen */
3442                         boost::shared_ptr<RouteList> r = routes.reader ();
3443                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3444                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3445                                         continue;
3446                                 }
3447                                 (*i)->set_listen (false, this);
3448                         }
3449                 }
3450
3451                 _listen_cnt++;
3452
3453         } else if (_listen_cnt > 0) {
3454
3455                 _listen_cnt--;
3456         }
3457
3458         update_route_solo_state ();
3459 }
3460 void
3461 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3462 {
3463         boost::shared_ptr<Route> route = wpr.lock ();
3464
3465         if (!route) {
3466                 /* should not happen */
3467                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3468                 return;
3469         }
3470
3471         bool send_changed = false;
3472
3473         if (route->solo_isolated()) {
3474                 if (_solo_isolated_cnt == 0) {
3475                         send_changed = true;
3476                 }
3477                 _solo_isolated_cnt++;
3478         } else if (_solo_isolated_cnt > 0) {
3479                 _solo_isolated_cnt--;
3480                 if (_solo_isolated_cnt == 0) {
3481                         send_changed = true;
3482                 }
3483         }
3484
3485         if (send_changed) {
3486                 IsolatedChanged (); /* EMIT SIGNAL */
3487         }
3488 }
3489
3490 void
3491 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
3492 {
3493         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3494
3495         if (!self_solo_change) {
3496                 // session doesn't care about changes to soloed-by-others
3497                 return;
3498         }
3499
3500         if (solo_update_disabled) {
3501                 // We know already
3502                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
3503                 return;
3504         }
3505
3506         boost::shared_ptr<Route> route = wpr.lock ();
3507         assert (route);
3508
3509         boost::shared_ptr<RouteList> r = routes.reader ();
3510         int32_t delta;
3511
3512         if (route->self_soloed()) {
3513                 delta = 1;
3514         } else {
3515                 delta = -1;
3516         }
3517
3518         RouteGroup* rg = route->route_group ();
3519         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
3520
3521         if (delta == 1 && Config->get_exclusive_solo()) {
3522
3523                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3524
3525                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3526                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3527                             (leave_group_alone && ((*i)->route_group() == rg))) {
3528                                 continue;
3529                         }
3530                         (*i)->set_solo (false, this);
3531                 }
3532         }
3533
3534         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3535
3536         solo_update_disabled = true;
3537
3538         RouteList uninvolved;
3539
3540         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3541
3542         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3543                 bool via_sends_only;
3544                 bool in_signal_flow;
3545
3546                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3547                     (leave_group_alone && ((*i)->route_group() == rg))) {
3548                         continue;
3549                 }
3550
3551                 in_signal_flow = false;
3552
3553                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3554
3555                 if ((*i)->feeds (route, &via_sends_only)) {
3556                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3557                         if (!via_sends_only) {
3558                                 if (!route->soloed_by_others_upstream()) {
3559                                         (*i)->mod_solo_by_others_downstream (delta);
3560                                 }
3561                         } else {
3562                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3563                         }
3564                         in_signal_flow = true;
3565                 } else {
3566                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3567                 }
3568
3569                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3570
3571                 if (route->feeds (*i, &via_sends_only)) {
3572                         /* propagate solo upstream only if routing other than
3573                            sends is involved, but do consider the other route
3574                            (*i) to be part of the signal flow even if only
3575                            sends are involved.
3576                         */
3577                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3578                                                                   route->name(),
3579                                                                   (*i)->name(),
3580                                                                   via_sends_only,
3581                                                                   route->soloed_by_others_downstream(),
3582                                                                   route->soloed_by_others_upstream()));
3583                         if (!via_sends_only) {
3584                                 if (!route->soloed_by_others_downstream()) {
3585                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3586                                         (*i)->mod_solo_by_others_upstream (delta);
3587                                 } else {
3588                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
3589                                 }
3590                         } else {
3591                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3592                         }
3593                         in_signal_flow = true;
3594                 } else {
3595                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3596                 }
3597
3598                 if (!in_signal_flow) {
3599                         uninvolved.push_back (*i);
3600                 }
3601         }
3602
3603         solo_update_disabled = false;
3604         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3605
3606         update_route_solo_state (r);
3607
3608         /* now notify that the mute state of the routes not involved in the signal
3609            pathway of the just-solo-changed route may have altered.
3610         */
3611
3612         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3613                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3614                 (*i)->act_on_mute ();
3615                 (*i)->mute_changed (this);
3616         }
3617
3618         SoloChanged (); /* EMIT SIGNAL */
3619         set_dirty();
3620 }
3621
3622 void
3623 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3624 {
3625         /* now figure out if anything that matters is soloed (or is "listening")*/
3626
3627         bool something_soloed = false;
3628         uint32_t listeners = 0;
3629         uint32_t isolated = 0;
3630
3631         if (!r) {
3632                 r = routes.reader();
3633         }
3634
3635         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3636                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3637                         something_soloed = true;
3638                 }
3639
3640                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3641                         if (Config->get_solo_control_is_listen_control()) {
3642                                 listeners++;
3643                         } else {
3644                                 (*i)->set_listen (false, this);
3645                         }
3646                 }
3647
3648                 if ((*i)->solo_isolated()) {
3649                         isolated++;
3650                 }
3651         }
3652
3653         if (something_soloed != _non_soloed_outs_muted) {
3654                 _non_soloed_outs_muted = something_soloed;
3655                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3656         }
3657
3658         _listen_cnt = listeners;
3659
3660         if (isolated != _solo_isolated_cnt) {
3661                 _solo_isolated_cnt = isolated;
3662                 IsolatedChanged (); /* EMIT SIGNAL */
3663         }
3664
3665         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3666                                                   something_soloed, listeners, isolated));
3667 }
3668
3669 boost::shared_ptr<RouteList>
3670 Session::get_routes_with_internal_returns() const
3671 {
3672         boost::shared_ptr<RouteList> r = routes.reader ();
3673         boost::shared_ptr<RouteList> rl (new RouteList);
3674
3675         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3676                 if ((*i)->internal_return ()) {
3677                         rl->push_back (*i);
3678                 }
3679         }
3680         return rl;
3681 }
3682
3683 bool
3684 Session::io_name_is_legal (const std::string& name)
3685 {
3686         boost::shared_ptr<RouteList> r = routes.reader ();
3687
3688         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3689                 if ((*i)->name() == name) {
3690                         return false;
3691                 }
3692
3693                 if ((*i)->has_io_processor_named (name)) {
3694                         return false;
3695                 }
3696         }
3697
3698         return true;
3699 }
3700
3701 void
3702 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
3703 {
3704         RouteList rl2;
3705         vector<string> connections;
3706
3707         /* if we are passed only a single route and we're not told to turn
3708          * others off, then just do the simple thing.
3709          */
3710
3711         if (flip_others == false && rl->size() == 1) {
3712                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
3713                 if (mt) {
3714                         mt->set_input_active (onoff);
3715                         return;
3716                 }
3717         }
3718
3719         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
3720
3721                 PortSet& ps ((*rt)->input()->ports());
3722
3723                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
3724                         p->get_connections (connections);
3725                 }
3726
3727                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
3728                         routes_using_input_from (*s, rl2);
3729                 }
3730
3731                 /* scan all relevant routes to see if others are on or off */
3732
3733                 bool others_are_already_on = false;
3734
3735                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3736
3737                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3738
3739                         if (!mt) {
3740                                 continue;
3741                         }
3742
3743                         if ((*r) != (*rt)) {
3744                                 if (mt->input_active()) {
3745                                         others_are_already_on = true;
3746                                 }
3747                         } else {
3748                                 /* this one needs changing */
3749                                 mt->set_input_active (onoff);
3750                         }
3751                 }
3752
3753                 if (flip_others) {
3754
3755                         /* globally reverse other routes */
3756
3757                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3758                                 if ((*r) != (*rt)) {
3759                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3760                                         if (mt) {
3761                                                 mt->set_input_active (!others_are_already_on);
3762                                         }
3763                                 }
3764                         }
3765                 }
3766         }
3767 }
3768
3769 void
3770 Session::routes_using_input_from (const string& str, RouteList& rl)
3771 {
3772         boost::shared_ptr<RouteList> r = routes.reader();
3773
3774         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3775                 if ((*i)->input()->connected_to (str)) {
3776                         rl.push_back (*i);
3777                 }
3778         }
3779 }
3780
3781 boost::shared_ptr<Route>
3782 Session::route_by_name (string name)
3783 {
3784         boost::shared_ptr<RouteList> r = routes.reader ();
3785
3786         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3787                 if ((*i)->name() == name) {
3788                         return *i;
3789                 }
3790         }
3791
3792         return boost::shared_ptr<Route> ((Route*) 0);
3793 }
3794
3795 boost::shared_ptr<Route>
3796 Session::route_by_id (PBD::ID id)
3797 {
3798         boost::shared_ptr<RouteList> r = routes.reader ();
3799
3800         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3801                 if ((*i)->id() == id) {
3802                         return *i;
3803                 }
3804         }
3805
3806         return boost::shared_ptr<Route> ((Route*) 0);
3807 }
3808
3809 boost::shared_ptr<Track>
3810 Session::track_by_diskstream_id (PBD::ID id)
3811 {
3812         boost::shared_ptr<RouteList> r = routes.reader ();
3813
3814         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3815                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3816                 if (t && t->using_diskstream_id (id)) {
3817                         return t;
3818                 }
3819         }
3820
3821         return boost::shared_ptr<Track> ();
3822 }
3823
3824 boost::shared_ptr<Route>
3825 Session::route_by_remote_id (uint32_t id)
3826 {
3827         boost::shared_ptr<RouteList> r = routes.reader ();
3828
3829         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3830                 if ((*i)->remote_control_id() == id) {
3831                         return *i;
3832                 }
3833         }
3834
3835         return boost::shared_ptr<Route> ((Route*) 0);
3836 }
3837
3838
3839 void
3840 Session::reassign_track_numbers ()
3841 {
3842         int64_t tn = 0;
3843         int64_t bn = 0;
3844         RouteList r (*(routes.reader ()));
3845         SignalOrderRouteSorter sorter;
3846         r.sort (sorter);
3847
3848         StateProtector sp (this);
3849
3850         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3851                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3852                         (*i)->set_track_number(++tn);
3853                 }
3854                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
3855                         (*i)->set_track_number(--bn);
3856                 }
3857         }
3858         const uint32_t decimals = ceilf (log10f (tn + 1));
3859         const bool decimals_changed = _track_number_decimals != decimals;
3860         _track_number_decimals = decimals;
3861
3862         if (decimals_changed && config.get_track_name_number ()) {
3863                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3864                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3865                         if (t) {
3866                                 t->resync_track_name();
3867                         }
3868                 }
3869                 // trigger GUI re-layout
3870                 config.ParameterChanged("track-name-number");
3871         }
3872 }
3873
3874 void
3875 Session::playlist_region_added (boost::weak_ptr<Region> w)
3876 {
3877         boost::shared_ptr<Region> r = w.lock ();
3878         if (!r) {
3879                 return;
3880         }
3881
3882         /* These are the operations that are currently in progress... */
3883         list<GQuark> curr = _current_trans_quarks;
3884         curr.sort ();
3885
3886         /* ...and these are the operations during which we want to update
3887            the session range location markers.
3888         */
3889         list<GQuark> ops;
3890         ops.push_back (Operations::capture);
3891         ops.push_back (Operations::paste);
3892         ops.push_back (Operations::duplicate_region);
3893         ops.push_back (Operations::insert_file);
3894         ops.push_back (Operations::insert_region);
3895         ops.push_back (Operations::drag_region_brush);
3896         ops.push_back (Operations::region_drag);
3897         ops.push_back (Operations::selection_grab);
3898         ops.push_back (Operations::region_fill);
3899         ops.push_back (Operations::fill_selection);
3900         ops.push_back (Operations::create_region);
3901         ops.push_back (Operations::region_copy);
3902         ops.push_back (Operations::fixed_time_region_copy);
3903         ops.sort ();
3904
3905         /* See if any of the current operations match the ones that we want */
3906         list<GQuark> in;
3907         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3908
3909         /* If so, update the session range markers */
3910         if (!in.empty ()) {
3911                 maybe_update_session_range (r->position (), r->last_frame ());
3912         }
3913 }
3914
3915 /** Update the session range markers if a is before the current start or
3916  *  b is after the current end.
3917  */
3918 void
3919 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3920 {
3921         if (_state_of_the_state & Loading) {
3922                 return;
3923         }
3924
3925         if (_session_range_location == 0) {
3926
3927                 add_session_range_location (a, b);
3928
3929         } else {
3930
3931                 if (a < _session_range_location->start()) {
3932                         _session_range_location->set_start (a);
3933                 }
3934
3935                 if (b > _session_range_location->end()) {
3936                         _session_range_location->set_end (b);
3937                 }
3938         }
3939 }
3940
3941 void
3942 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3943 {
3944         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3945                 maybe_update_session_range (i->to, i->to + i->length);
3946         }
3947 }
3948
3949 void
3950 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3951 {
3952         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3953                 maybe_update_session_range (i->from, i->to);
3954         }
3955 }
3956
3957 /* Region management */
3958
3959 boost::shared_ptr<Region>
3960 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3961 {
3962         const RegionFactory::RegionMap& regions (RegionFactory::regions());
3963         RegionFactory::RegionMap::const_iterator i;
3964         boost::shared_ptr<Region> region;
3965
3966         Glib::Threads::Mutex::Lock lm (region_lock);
3967
3968         for (i = regions.begin(); i != regions.end(); ++i) {
3969
3970                 region = i->second;
3971
3972                 if (region->whole_file()) {
3973
3974                         if (child->source_equivalent (region)) {
3975                                 return region;
3976                         }
3977                 }
3978         }
3979
3980         return boost::shared_ptr<Region> ();
3981 }
3982
3983 int
3984 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3985 {
3986         set<boost::shared_ptr<Region> > relevant_regions;
3987
3988         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3989                 RegionFactory::get_regions_using_source (*s, relevant_regions);
3990         }
3991
3992         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3993                 set<boost::shared_ptr<Region> >::iterator tmp;
3994
3995                 tmp = r;
3996                 ++tmp;
3997
3998                 playlists->destroy_region (*r);
3999                 RegionFactory::map_remove (*r);
4000
4001                 (*r)->drop_sources ();
4002                 (*r)->drop_references ();
4003
4004                 relevant_regions.erase (r);
4005
4006                 r = tmp;
4007         }
4008
4009         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4010
4011                 {
4012                         Glib::Threads::Mutex::Lock ls (source_lock);
4013                         /* remove from the main source list */
4014                         sources.erase ((*s)->id());
4015                 }
4016
4017                 (*s)->mark_for_remove ();
4018                 (*s)->drop_references ();
4019
4020                 s = srcs.erase (s);
4021         }
4022
4023         return 0;
4024 }
4025
4026 int
4027 Session::remove_last_capture ()
4028 {
4029         list<boost::shared_ptr<Source> > srcs;
4030
4031         boost::shared_ptr<RouteList> rl = routes.reader ();
4032         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4033                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4034                 if (!tr) {
4035                         continue;
4036                 }
4037
4038                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4039
4040                 if (!l.empty()) {
4041                         srcs.insert (srcs.end(), l.begin(), l.end());
4042                         l.clear ();
4043                 }
4044         }
4045
4046         destroy_sources (srcs);
4047
4048         save_state (_current_snapshot_name);
4049
4050         return 0;
4051 }
4052
4053 /* Source Management */
4054
4055 void
4056 Session::add_source (boost::shared_ptr<Source> source)
4057 {
4058         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4059         pair<SourceMap::iterator,bool> result;
4060
4061         entry.first = source->id();
4062         entry.second = source;
4063
4064         {
4065                 Glib::Threads::Mutex::Lock lm (source_lock);
4066                 result = sources.insert (entry);
4067         }
4068
4069         if (result.second) {
4070
4071                 /* yay, new source */
4072
4073                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4074
4075                 if (fs) {
4076                         if (!fs->within_session()) {
4077                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4078                         }
4079                 }
4080
4081                 set_dirty();
4082
4083                 boost::shared_ptr<AudioFileSource> afs;
4084
4085                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4086                         if (Config->get_auto_analyse_audio()) {
4087                                 Analyser::queue_source_for_analysis (source, false);
4088                         }
4089                 }
4090
4091                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4092         }
4093 }
4094
4095 void
4096 Session::remove_source (boost::weak_ptr<Source> src)
4097 {
4098         if (_state_of_the_state & Deletion) {
4099                 return;
4100         }
4101
4102         SourceMap::iterator i;
4103         boost::shared_ptr<Source> source = src.lock();
4104
4105         if (!source) {
4106                 return;
4107         }
4108
4109         {
4110                 Glib::Threads::Mutex::Lock lm (source_lock);
4111
4112                 if ((i = sources.find (source->id())) != sources.end()) {
4113                         sources.erase (i);
4114                 }
4115         }
4116
4117         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4118
4119                 /* save state so we don't end up with a session file
4120                    referring to non-existent sources.
4121                 */
4122
4123                 save_state (_current_snapshot_name);
4124         }
4125 }
4126
4127 boost::shared_ptr<Source>
4128 Session::source_by_id (const PBD::ID& id)
4129 {
4130         Glib::Threads::Mutex::Lock lm (source_lock);
4131         SourceMap::iterator i;
4132         boost::shared_ptr<Source> source;
4133
4134         if ((i = sources.find (id)) != sources.end()) {
4135                 source = i->second;
4136         }
4137
4138         return source;
4139 }
4140
4141 boost::shared_ptr<AudioFileSource>
4142 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4143 {
4144         /* Restricted to audio files because only audio sources have channel
4145            as a property.
4146         */
4147
4148         Glib::Threads::Mutex::Lock lm (source_lock);
4149
4150         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4151                 boost::shared_ptr<AudioFileSource> afs
4152                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4153
4154                 if (afs && afs->path() == path && chn == afs->channel()) {
4155                         return afs;
4156                 }
4157         }
4158
4159         return boost::shared_ptr<AudioFileSource>();
4160 }
4161
4162 boost::shared_ptr<MidiSource>
4163 Session::midi_source_by_path (const std::string& path) const
4164 {
4165         /* Restricted to MIDI files because audio sources require a channel
4166            for unique identification, in addition to a path.
4167         */
4168
4169         Glib::Threads::Mutex::Lock lm (source_lock);
4170
4171         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4172                 boost::shared_ptr<MidiSource> ms
4173                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4174                 boost::shared_ptr<FileSource> fs
4175                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4176
4177                 if (ms && fs && fs->path() == path) {
4178                         return ms;
4179                 }
4180         }
4181
4182         return boost::shared_ptr<MidiSource>();
4183 }
4184
4185 uint32_t
4186 Session::count_sources_by_origin (const string& path)
4187 {
4188         uint32_t cnt = 0;
4189         Glib::Threads::Mutex::Lock lm (source_lock);
4190
4191         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4192                 boost::shared_ptr<FileSource> fs
4193                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4194
4195                 if (fs && fs->origin() == path) {
4196                         ++cnt;
4197                 }
4198         }
4199
4200         return cnt;
4201 }
4202
4203 string
4204 Session::peak_path (string base) const
4205 {
4206         if (Glib::path_is_absolute (base)) {
4207
4208                 /* rip the session dir from the audiofile source */
4209
4210                 string session_path;
4211                 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4212                 bool in_another_session = true;
4213
4214                 if (base.find (interchange_dir_string) != string::npos) {
4215
4216                         session_path = Glib::path_get_dirname (base); /* now ends in audiofiles */
4217                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4218                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4219                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4220
4221                         /* see if it is within our session */
4222
4223                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4224                                 if (i->path == session_path) {
4225                                         in_another_session = false;
4226                                         break;
4227                                 }
4228                         }
4229                 } else {
4230                         in_another_session = false;
4231                 }
4232
4233
4234                 if (in_another_session) {
4235                         SessionDirectory sd (session_path);
4236                         return Glib::build_filename (sd.peak_path(), Glib::path_get_basename (base) + peakfile_suffix);
4237                 }
4238         }
4239
4240         base = Glib::path_get_basename (base);
4241         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
4242 }
4243
4244 string
4245 Session::new_audio_source_path_for_embedded (const std::string& path)
4246 {
4247         /* embedded source:
4248          *
4249          * we know that the filename is already unique because it exists
4250          * out in the filesystem.
4251          *
4252          * However, when we bring it into the session, we could get a
4253          * collision.
4254          *
4255          * Eg. two embedded files:
4256          *
4257          *          /foo/bar/baz.wav
4258          *          /frob/nic/baz.wav
4259          *
4260          * When merged into session, these collide.
4261          *
4262          * There will not be a conflict with in-memory sources
4263          * because when the source was created we already picked
4264          * a unique name for it.
4265          *
4266          * This collision is not likely to be common, but we have to guard
4267          * against it.  So, if there is a collision, take the md5 hash of the
4268          * the path, and use that as the filename instead.
4269          */
4270
4271         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4272         string base = Glib::path_get_basename (path);
4273         string newpath = Glib::build_filename (sdir.sound_path(), base);
4274
4275         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4276
4277                 MD5 md5;
4278
4279                 md5.digestString (path.c_str());
4280                 md5.writeToString ();
4281                 base = md5.digestChars;
4282
4283                 string ext = get_suffix (path);
4284
4285                 if (!ext.empty()) {
4286                         base += '.';
4287                         base += ext;
4288                 }
4289
4290                 newpath = Glib::build_filename (sdir.sound_path(), base);
4291
4292                 /* if this collides, we're screwed */
4293
4294                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4295                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4296                         return string();
4297                 }
4298
4299         }
4300
4301         return newpath;
4302 }
4303
4304 /** Return true if there are no audio file sources that use @param name as
4305  * the filename component of their path.
4306  *
4307  * Return false otherwise.
4308  *
4309  * This method MUST ONLY be used to check in-session, mono files since it
4310  * hard-codes the channel of the audio file source we are looking for as zero.
4311  *
4312  * If/when Ardour supports native files in non-mono formats, the logic here
4313  * will need to be revisited.
4314  */
4315 bool
4316 Session::audio_source_name_is_unique (const string& name)
4317 {
4318         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4319         vector<space_and_path>::iterator i;
4320         uint32_t existing = 0;
4321
4322         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4323
4324                 /* note that we search *without* the extension so that
4325                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4326                    in the event that this new name is required for
4327                    a file format change.
4328                 */
4329
4330                 const string spath = *i;
4331
4332                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4333                         existing++;
4334                         break;
4335                 }
4336
4337                 /* it is possible that we have the path already
4338                  * assigned to a source that has not yet been written
4339                  * (ie. the write source for a diskstream). we have to
4340                  * check this in order to make sure that our candidate
4341                  * path isn't used again, because that can lead to
4342                  * two Sources point to the same file with different
4343                  * notions of their removability.
4344                  */
4345
4346
4347                 string possible_path = Glib::build_filename (spath, name);
4348
4349                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4350                         existing++;
4351                         break;
4352                 }
4353         }
4354
4355         return (existing == 0);
4356 }
4357
4358 string
4359 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)
4360 {
4361         ostringstream sstr;
4362         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4363
4364         if (destructive) {
4365                 sstr << 'T';
4366                 sstr << setfill ('0') << setw (4) << cnt;
4367                 sstr << legalized_base;
4368         } else {
4369                 sstr << legalized_base;
4370
4371                 if (take_required || related_exists) {
4372                         sstr << '-';
4373                         sstr << cnt;
4374                 }
4375         }
4376
4377         if (nchan == 2) {
4378                 if (chan == 0) {
4379                         sstr << "%L";
4380                 } else {
4381                         sstr << "%R";
4382                 }
4383         } else if (nchan > 2) {
4384                 if (nchan < 26) {
4385                         sstr << '%';
4386                         sstr << 'a' + chan;
4387                 } else {
4388                         /* XXX what? more than 26 channels! */
4389                         sstr << '%';
4390                         sstr << chan+1;
4391                 }
4392         }
4393
4394         sstr << ext;
4395
4396         return sstr.str();
4397 }
4398
4399 /** Return a unique name based on \a base for a new internal audio source */
4400 string
4401 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4402 {
4403         uint32_t cnt;
4404         string possible_name;
4405         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4406         string legalized;
4407         bool some_related_source_name_exists = false;
4408
4409         legalized = legalize_for_path (base);
4410
4411         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4412
4413         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4414
4415                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4416
4417                 if (audio_source_name_is_unique (possible_name)) {
4418                         break;
4419                 }
4420
4421                 some_related_source_name_exists = true;
4422
4423                 if (cnt > limit) {
4424                         error << string_compose(
4425                                         _("There are already %1 recordings for %2, which I consider too many."),
4426                                         limit, base) << endmsg;
4427                         destroy ();
4428                         throw failed_constructor();
4429                 }
4430         }
4431
4432         /* We've established that the new name does not exist in any session
4433          * directory, so now find out which one we should use for this new
4434          * audio source.
4435          */
4436
4437         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4438
4439         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4440
4441         return s;
4442 }
4443
4444 /** Return a unique name based on `base` for a new internal MIDI source */
4445 string
4446 Session::new_midi_source_path (const string& base)
4447 {
4448         uint32_t cnt;
4449         char buf[PATH_MAX+1];
4450         const uint32_t limit = 10000;
4451         string legalized;
4452         string possible_path;
4453         string possible_name;
4454
4455         buf[0] = '\0';
4456         legalized = legalize_for_path (base);
4457
4458         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4459         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4460
4461         /* - the main session folder is the first in the vector.
4462          * - after checking all locations for file-name uniqueness,
4463          *   we keep the one from the last iteration as new file name
4464          * - midi files are small and should just be kept in the main session-folder
4465          *
4466          * -> reverse the array, check main session folder last and use that as location
4467          *    for MIDI files.
4468          */
4469         std::reverse(sdirs.begin(), sdirs.end());
4470
4471         for (cnt = 1; cnt <= limit; ++cnt) {
4472
4473                 vector<space_and_path>::iterator i;
4474                 uint32_t existing = 0;
4475
4476                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4477
4478                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4479                         possible_name = buf;
4480
4481                         possible_path = Glib::build_filename (*i, possible_name);
4482
4483                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4484                                 existing++;
4485                         }
4486
4487                         if (midi_source_by_path (possible_path)) {
4488                                 existing++;
4489                         }
4490                 }
4491
4492                 if (existing == 0) {
4493                         break;
4494                 }
4495
4496                 if (cnt > limit) {
4497                         error << string_compose(
4498                                         _("There are already %1 recordings for %2, which I consider too many."),
4499                                         limit, base) << endmsg;
4500                         destroy ();
4501                         return 0;
4502                 }
4503         }
4504
4505         /* No need to "find best location" for software/app-based RAID, because
4506            MIDI is so small that we always put it in the same place.
4507         */
4508
4509         return possible_path;
4510 }
4511
4512
4513 /** Create a new within-session audio source */
4514 boost::shared_ptr<AudioFileSource>
4515 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4516 {
4517         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4518
4519         if (!path.empty()) {
4520                 return boost::dynamic_pointer_cast<AudioFileSource> (
4521                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
4522         } else {
4523                 throw failed_constructor ();
4524         }
4525 }
4526
4527 /** Create a new within-session MIDI source */
4528 boost::shared_ptr<MidiSource>
4529 Session::create_midi_source_for_session (string const & basic_name)
4530 {
4531         const string path = new_midi_source_path (basic_name);
4532
4533         if (!path.empty()) {
4534                 return boost::dynamic_pointer_cast<SMFSource> (
4535                         SourceFactory::createWritable (
4536                                 DataType::MIDI, *this, path, false, frame_rate()));
4537         } else {
4538                 throw failed_constructor ();
4539         }
4540 }
4541
4542 /** Create a new within-session MIDI source */
4543 boost::shared_ptr<MidiSource>
4544 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4545 {
4546         /* the caller passes in the track the source will be used in,
4547            so that we can keep the numbering sane.
4548
4549            Rationale: a track with the name "Foo" that has had N
4550            captures carried out so far will ALREADY have a write source
4551            named "Foo-N+1.mid" waiting to be used for the next capture.
4552
4553            If we call new_midi_source_name() we will get "Foo-N+2". But
4554            there is no region corresponding to "Foo-N+1", so when
4555            "Foo-N+2" appears in the track, the gap presents the user
4556            with odd behaviour - why did it skip past Foo-N+1?
4557
4558            We could explain this to the user in some odd way, but
4559            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4560            use "Foo-N+1" here.
4561
4562            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4563         */
4564
4565         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4566         assert (mt);
4567         std::string name = track->steal_write_source_name ();
4568
4569         if (name.empty()) {
4570                 return boost::shared_ptr<MidiSource>();
4571         }
4572
4573         /* MIDI files are small, just put them in the first location of the
4574            session source search path.
4575         */
4576
4577         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4578
4579         return boost::dynamic_pointer_cast<SMFSource> (
4580                 SourceFactory::createWritable (
4581                         DataType::MIDI, *this, path, false, frame_rate()));
4582 }
4583
4584
4585 void
4586 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4587 {
4588         if (playlist->hidden()) {
4589                 return;
4590         }
4591
4592         playlists->add (playlist);
4593
4594         if (unused) {
4595                 playlist->release();
4596         }
4597
4598         set_dirty();
4599 }
4600
4601 void
4602 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4603 {
4604         if (_state_of_the_state & Deletion) {
4605                 return;
4606         }
4607
4608         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4609
4610         if (!playlist) {
4611                 return;
4612         }
4613
4614         playlists->remove (playlist);
4615
4616         set_dirty();
4617 }
4618
4619 void
4620 Session::set_audition (boost::shared_ptr<Region> r)
4621 {
4622         pending_audition_region = r;
4623         add_post_transport_work (PostTransportAudition);
4624         _butler->schedule_transport_work ();
4625 }
4626
4627 void
4628 Session::audition_playlist ()
4629 {
4630         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4631         ev->region.reset ();
4632         queue_event (ev);
4633 }
4634
4635 void
4636 Session::non_realtime_set_audition ()
4637 {
4638         assert (pending_audition_region);
4639         auditioner->audition_region (pending_audition_region);
4640         pending_audition_region.reset ();
4641         AuditionActive (true); /* EMIT SIGNAL */
4642 }
4643
4644 void
4645 Session::audition_region (boost::shared_ptr<Region> r)
4646 {
4647         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4648         ev->region = r;
4649         queue_event (ev);
4650 }
4651
4652 void
4653 Session::cancel_audition ()
4654 {
4655         if (!auditioner) {
4656                 return;
4657         }
4658         if (auditioner->auditioning()) {
4659                 auditioner->cancel_audition ();
4660                 AuditionActive (false); /* EMIT SIGNAL */
4661         }
4662 }
4663
4664 bool
4665 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4666 {
4667         if (a->is_monitor()) {
4668                 return true;
4669         }
4670         if (b->is_monitor()) {
4671                 return false;
4672         }
4673         return a->order_key () < b->order_key ();
4674 }
4675
4676 bool
4677 Session::is_auditioning () const
4678 {
4679         /* can be called before we have an auditioner object */
4680         if (auditioner) {
4681                 return auditioner->auditioning();
4682         } else {
4683                 return false;
4684         }
4685 }
4686
4687 void
4688 Session::graph_reordered ()
4689 {
4690         /* don't do this stuff if we are setting up connections
4691            from a set_state() call or creating new tracks. Ditto for deletion.
4692         */
4693
4694         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress) {
4695                 return;
4696         }
4697
4698         /* every track/bus asked for this to be handled but it was deferred because
4699            we were connecting. do it now.
4700         */
4701
4702         request_input_change_handling ();
4703
4704         resort_routes ();
4705
4706         /* force all diskstreams to update their capture offset values to
4707            reflect any changes in latencies within the graph.
4708         */
4709
4710         boost::shared_ptr<RouteList> rl = routes.reader ();
4711         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4712                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4713                 if (tr) {
4714                         tr->set_capture_offset ();
4715                 }
4716         }
4717 }
4718
4719 /** @return Number of frames that there is disk space available to write,
4720  *  if known.
4721  */
4722 boost::optional<framecnt_t>
4723 Session::available_capture_duration ()
4724 {
4725         Glib::Threads::Mutex::Lock lm (space_lock);
4726
4727         if (_total_free_4k_blocks_uncertain) {
4728                 return boost::optional<framecnt_t> ();
4729         }
4730
4731         float sample_bytes_on_disk = 4.0; // keep gcc happy
4732
4733         switch (config.get_native_file_data_format()) {
4734         case FormatFloat:
4735                 sample_bytes_on_disk = 4.0;
4736                 break;
4737
4738         case FormatInt24:
4739                 sample_bytes_on_disk = 3.0;
4740                 break;
4741
4742         case FormatInt16:
4743                 sample_bytes_on_disk = 2.0;
4744                 break;
4745
4746         default:
4747                 /* impossible, but keep some gcc versions happy */
4748                 fatal << string_compose (_("programming error: %1"),
4749                                          X_("illegal native file data format"))
4750                       << endmsg;
4751                 abort(); /*NOTREACHED*/
4752         }
4753
4754         double scale = 4096.0 / sample_bytes_on_disk;
4755
4756         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4757                 return max_framecnt;
4758         }
4759
4760         return (framecnt_t) floor (_total_free_4k_blocks * scale);
4761 }
4762
4763 void
4764 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
4765 {
4766         {
4767                 RCUWriter<BundleList> writer (_bundles);
4768                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4769                 b->push_back (bundle);
4770         }
4771
4772         if (emit_signal) {
4773                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
4774         }
4775
4776         set_dirty();
4777 }
4778
4779 void
4780 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
4781 {
4782         bool removed = false;
4783
4784         {
4785                 RCUWriter<BundleList> writer (_bundles);
4786                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4787                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
4788
4789                 if (i != b->end()) {
4790                         b->erase (i);
4791                         removed = true;
4792                 }
4793         }
4794
4795         if (removed) {
4796                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
4797         }
4798
4799         set_dirty();
4800 }
4801
4802 boost::shared_ptr<Bundle>
4803 Session::bundle_by_name (string name) const
4804 {
4805         boost::shared_ptr<BundleList> b = _bundles.reader ();
4806
4807         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
4808                 if ((*i)->name() == name) {
4809                         return* i;
4810                 }
4811         }
4812
4813         return boost::shared_ptr<Bundle> ();
4814 }
4815
4816 void
4817 Session::tempo_map_changed (const PropertyChange&)
4818 {
4819         clear_clicks ();
4820
4821         playlists->update_after_tempo_map_change ();
4822
4823         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4824
4825         set_dirty ();
4826 }
4827
4828 void
4829 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
4830 {
4831         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
4832                 (*i)->recompute_frames_from_bbt ();
4833         }
4834 }
4835
4836 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4837  * the given count with the current block size.
4838  */
4839 void
4840 Session::ensure_buffers (ChanCount howmany)
4841 {
4842         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4843 }
4844
4845 void
4846 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4847 {
4848         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4849                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4850         }
4851 }
4852
4853 uint32_t
4854 Session::next_insert_id ()
4855 {
4856         /* this doesn't really loop forever. just think about it */
4857
4858         while (true) {
4859                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4860                         if (!insert_bitset[n]) {
4861                                 insert_bitset[n] = true;
4862                                 return n;
4863
4864                         }
4865                 }
4866
4867                 /* none available, so resize and try again */
4868
4869                 insert_bitset.resize (insert_bitset.size() + 16, false);
4870         }
4871 }
4872
4873 uint32_t
4874 Session::next_send_id ()
4875 {
4876         /* this doesn't really loop forever. just think about it */
4877
4878         while (true) {
4879                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4880                         if (!send_bitset[n]) {
4881                                 send_bitset[n] = true;
4882                                 return n;
4883
4884                         }
4885                 }
4886
4887                 /* none available, so resize and try again */
4888
4889                 send_bitset.resize (send_bitset.size() + 16, false);
4890         }
4891 }
4892
4893 uint32_t
4894 Session::next_aux_send_id ()
4895 {
4896         /* this doesn't really loop forever. just think about it */
4897
4898         while (true) {
4899                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4900                         if (!aux_send_bitset[n]) {
4901                                 aux_send_bitset[n] = true;
4902                                 return n;
4903
4904                         }
4905                 }
4906
4907                 /* none available, so resize and try again */
4908
4909                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4910         }
4911 }
4912
4913 uint32_t
4914 Session::next_return_id ()
4915 {
4916         /* this doesn't really loop forever. just think about it */
4917
4918         while (true) {
4919                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
4920                         if (!return_bitset[n]) {
4921                                 return_bitset[n] = true;
4922                                 return n;
4923
4924                         }
4925                 }
4926
4927                 /* none available, so resize and try again */
4928
4929                 return_bitset.resize (return_bitset.size() + 16, false);
4930         }
4931 }
4932
4933 void
4934 Session::mark_send_id (uint32_t id)
4935 {
4936         if (id >= send_bitset.size()) {
4937                 send_bitset.resize (id+16, false);
4938         }
4939         if (send_bitset[id]) {
4940                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4941         }
4942         send_bitset[id] = true;
4943 }
4944
4945 void
4946 Session::mark_aux_send_id (uint32_t id)
4947 {
4948         if (id >= aux_send_bitset.size()) {
4949                 aux_send_bitset.resize (id+16, false);
4950         }
4951         if (aux_send_bitset[id]) {
4952                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4953         }
4954         aux_send_bitset[id] = true;
4955 }
4956
4957 void
4958 Session::mark_return_id (uint32_t id)
4959 {
4960         if (id >= return_bitset.size()) {
4961                 return_bitset.resize (id+16, false);
4962         }
4963         if (return_bitset[id]) {
4964                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4965         }
4966         return_bitset[id] = true;
4967 }
4968
4969 void
4970 Session::mark_insert_id (uint32_t id)
4971 {
4972         if (id >= insert_bitset.size()) {
4973                 insert_bitset.resize (id+16, false);
4974         }
4975         if (insert_bitset[id]) {
4976                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4977         }
4978         insert_bitset[id] = true;
4979 }
4980
4981 void
4982 Session::unmark_send_id (uint32_t id)
4983 {
4984         if (id < send_bitset.size()) {
4985                 send_bitset[id] = false;
4986         }
4987 }
4988
4989 void
4990 Session::unmark_aux_send_id (uint32_t id)
4991 {
4992         if (id < aux_send_bitset.size()) {
4993                 aux_send_bitset[id] = false;
4994         }
4995 }
4996
4997 void
4998 Session::unmark_return_id (uint32_t id)
4999 {
5000         if (id < return_bitset.size()) {
5001                 return_bitset[id] = false;
5002         }
5003 }
5004
5005 void
5006 Session::unmark_insert_id (uint32_t id)
5007 {
5008         if (id < insert_bitset.size()) {
5009                 insert_bitset[id] = false;
5010         }
5011 }
5012
5013 void
5014 Session::reset_native_file_format ()
5015 {
5016         boost::shared_ptr<RouteList> rl = routes.reader ();
5017         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5018                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5019                 if (tr) {
5020                         /* don't save state as we do this, there's no point
5021                          */
5022
5023                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5024                         tr->reset_write_sources (false);
5025                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5026                 }
5027         }
5028 }
5029
5030 bool
5031 Session::route_name_unique (string n) const
5032 {
5033         boost::shared_ptr<RouteList> r = routes.reader ();
5034
5035         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5036                 if ((*i)->name() == n) {
5037                         return false;
5038                 }
5039         }
5040
5041         return true;
5042 }
5043
5044 bool
5045 Session::route_name_internal (string n) const
5046 {
5047         if (auditioner && auditioner->name() == n) {
5048                 return true;
5049         }
5050
5051         if (_click_io && _click_io->name() == n) {
5052                 return true;
5053         }
5054
5055         return false;
5056 }
5057
5058 int
5059 Session::freeze_all (InterThreadInfo& itt)
5060 {
5061         boost::shared_ptr<RouteList> r = routes.reader ();
5062
5063         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5064
5065                 boost::shared_ptr<Track> t;
5066
5067                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5068                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
5069                            of every track.
5070                         */
5071                         t->freeze_me (itt);
5072                 }
5073         }
5074
5075         return 0;
5076 }
5077
5078 boost::shared_ptr<Region>
5079 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5080                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5081                           InterThreadInfo& itt,
5082                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5083                           bool for_export, bool for_freeze)
5084 {
5085         boost::shared_ptr<Region> result;
5086         boost::shared_ptr<Playlist> playlist;
5087         boost::shared_ptr<Source> source;
5088         ChanCount diskstream_channels (track.n_channels());
5089         framepos_t position;
5090         framecnt_t this_chunk;
5091         framepos_t to_do;
5092         framepos_t latency_skip;
5093         BufferSet buffers;
5094         framepos_t len = end - start;
5095         bool need_block_size_reset = false;
5096         ChanCount const max_proc = track.max_processor_streams ();
5097         string legal_playlist_name;
5098         string possible_path;
5099
5100         if (end <= start) {
5101                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5102                                          end, start) << endmsg;
5103                 return result;
5104         }
5105
5106         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5107                         include_endpoint, for_export, for_freeze);
5108
5109         if (diskstream_channels.n(track.data_type()) < 1) {
5110                 error << _("Cannot write a range with no data.") << endmsg;
5111                 return result;
5112         }
5113
5114         // block all process callback handling
5115
5116         block_processing ();
5117
5118         {
5119                 // synchronize with AudioEngine::process_callback()
5120                 // make sure processing is not currently running
5121                 // and processing_blocked() is honored before
5122                 // acquiring thread buffers
5123                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5124         }
5125
5126         _bounce_processing_active = true;
5127
5128         /* call tree *MUST* hold route_lock */
5129
5130         if ((playlist = track.playlist()) == 0) {
5131                 goto out;
5132         }
5133
5134         legal_playlist_name = legalize_for_path (playlist->name());
5135
5136         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5137
5138                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5139                 string path = ((track.data_type() == DataType::AUDIO)
5140                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5141                                : new_midi_source_path (legal_playlist_name));
5142
5143                 if (path.empty()) {
5144                         goto out;
5145                 }
5146
5147                 try {
5148                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5149                 }
5150
5151                 catch (failed_constructor& err) {
5152                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5153                         goto out;
5154                 }
5155
5156                 srcs.push_back (source);
5157         }
5158
5159         /* tell redirects that care that we are about to use a much larger
5160          * blocksize. this will flush all plugins too, so that they are ready
5161          * to be used for this process.
5162          */
5163
5164         need_block_size_reset = true;
5165         track.set_block_size (bounce_chunk_size);
5166         _engine.main_thread()->get_buffers ();
5167
5168         position = start;
5169         to_do = len;
5170         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5171
5172         /* create a set of reasonably-sized buffers */
5173         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5174                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5175         }
5176         buffers.set_count (max_proc);
5177
5178         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5179                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5180                 boost::shared_ptr<MidiSource> ms;
5181                 if (afs) {
5182                         afs->prepare_for_peakfile_writes ();
5183                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5184                         Source::Lock lock(ms->mutex());
5185                         ms->mark_streaming_write_started(lock);
5186                 }
5187         }
5188
5189         while (to_do && !itt.cancel) {
5190
5191                 this_chunk = min (to_do, bounce_chunk_size);
5192
5193                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5194                         goto out;
5195                 }
5196
5197                 start += this_chunk;
5198                 to_do -= this_chunk;
5199                 itt.progress = (float) (1.0 - ((double) to_do / len));
5200
5201                 if (latency_skip >= bounce_chunk_size) {
5202                         latency_skip -= bounce_chunk_size;
5203                         continue;
5204                 }
5205
5206                 const framecnt_t current_chunk = this_chunk - latency_skip;
5207
5208                 uint32_t n = 0;
5209                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5210                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5211                         boost::shared_ptr<MidiSource> ms;
5212
5213                         if (afs) {
5214                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5215                                         goto out;
5216                                 }
5217                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5218                                 Source::Lock lock(ms->mutex());
5219
5220                                 const MidiBuffer& buf = buffers.get_midi(0);
5221                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5222                                         Evoral::Event<framepos_t> ev = *i;
5223                                         ev.set_time(ev.time() - position);
5224                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5225                                 }
5226                         }
5227                 }
5228                 latency_skip = 0;
5229         }
5230
5231         /* post-roll, pick up delayed processor output */
5232         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5233
5234         while (latency_skip && !itt.cancel) {
5235                 this_chunk = min (latency_skip, bounce_chunk_size);
5236                 latency_skip -= this_chunk;
5237
5238                 buffers.silence (this_chunk, 0);
5239                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5240
5241                 uint32_t n = 0;
5242                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5243                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5244
5245                         if (afs) {
5246                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5247                                         goto out;
5248                                 }
5249                         }
5250                 }
5251         }
5252
5253         if (!itt.cancel) {
5254
5255                 time_t now;
5256                 struct tm* xnow;
5257                 time (&now);
5258                 xnow = localtime (&now);
5259
5260                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5261                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5262                         boost::shared_ptr<MidiSource> ms;
5263
5264                         if (afs) {
5265                                 afs->update_header (position, *xnow, now);
5266                                 afs->flush_header ();
5267                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5268                                 Source::Lock lock(ms->mutex());
5269                                 ms->mark_streaming_write_completed(lock);
5270                         }
5271                 }
5272
5273                 /* construct a region to represent the bounced material */
5274
5275                 PropertyList plist;
5276
5277                 plist.add (Properties::start, 0);
5278                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5279                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5280
5281                 result = RegionFactory::create (srcs, plist);
5282
5283         }
5284
5285   out:
5286         if (!result) {
5287                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5288                         (*src)->mark_for_remove ();
5289                         (*src)->drop_references ();
5290                 }
5291
5292         } else {
5293                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5294                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5295
5296                         if (afs)
5297                                 afs->done_with_peakfile_writes ();
5298                 }
5299         }
5300
5301         _bounce_processing_active = false;
5302
5303         if (need_block_size_reset) {
5304                 _engine.main_thread()->drop_buffers ();
5305                 track.set_block_size (get_block_size());
5306         }
5307
5308         unblock_processing ();
5309
5310         return result;
5311 }
5312
5313 gain_t*
5314 Session::gain_automation_buffer() const
5315 {
5316         return ProcessThread::gain_automation_buffer ();
5317 }
5318
5319 gain_t*
5320 Session::trim_automation_buffer() const
5321 {
5322         return ProcessThread::trim_automation_buffer ();
5323 }
5324
5325 gain_t*
5326 Session::send_gain_automation_buffer() const
5327 {
5328         return ProcessThread::send_gain_automation_buffer ();
5329 }
5330
5331 pan_t**
5332 Session::pan_automation_buffer() const
5333 {
5334         return ProcessThread::pan_automation_buffer ();
5335 }
5336
5337 BufferSet&
5338 Session::get_silent_buffers (ChanCount count)
5339 {
5340         return ProcessThread::get_silent_buffers (count);
5341 }
5342
5343 BufferSet&
5344 Session::get_scratch_buffers (ChanCount count, bool silence)
5345 {
5346         return ProcessThread::get_scratch_buffers (count, silence);
5347 }
5348
5349 BufferSet&
5350 Session::get_route_buffers (ChanCount count, bool silence)
5351 {
5352         return ProcessThread::get_route_buffers (count, silence);
5353 }
5354
5355
5356 BufferSet&
5357 Session::get_mix_buffers (ChanCount count)
5358 {
5359         return ProcessThread::get_mix_buffers (count);
5360 }
5361
5362 uint32_t
5363 Session::ntracks () const
5364 {
5365         uint32_t n = 0;
5366         boost::shared_ptr<RouteList> r = routes.reader ();
5367
5368         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5369                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5370                         ++n;
5371                 }
5372         }
5373
5374         return n;
5375 }
5376
5377 uint32_t
5378 Session::nbusses () const
5379 {
5380         uint32_t n = 0;
5381         boost::shared_ptr<RouteList> r = routes.reader ();
5382
5383         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5384                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5385                         ++n;
5386                 }
5387         }
5388
5389         return n;
5390 }
5391
5392 void
5393 Session::add_automation_list(AutomationList *al)
5394 {
5395         automation_lists[al->id()] = al;
5396 }
5397
5398 /** @return true if there is at least one record-enabled track, otherwise false */
5399 bool
5400 Session::have_rec_enabled_track () const
5401 {
5402         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5403 }
5404
5405 bool
5406 Session::have_rec_disabled_track () const
5407 {
5408     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5409 }
5410
5411 /** Update the state of our rec-enabled tracks flag */
5412 void
5413 Session::update_route_record_state ()
5414 {
5415         boost::shared_ptr<RouteList> rl = routes.reader ();
5416         RouteList::iterator i = rl->begin();
5417         while (i != rl->end ()) {
5418
5419                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5420                 if (tr && tr->record_enabled ()) {
5421                         break;
5422                 }
5423
5424                 ++i;
5425         }
5426
5427         int const old = g_atomic_int_get (&_have_rec_enabled_track);
5428
5429         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
5430
5431         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
5432                 RecordStateChanged (); /* EMIT SIGNAL */
5433         }
5434
5435         for (i = rl->begin(); i != rl->end (); ++i) {
5436                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5437                 if (tr && !tr->record_enabled ()) {
5438                         break;
5439                 }
5440         }
5441
5442         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
5443
5444         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
5445
5446         if (record_status() == Recording && record_arm_state_changed ) {
5447                 RecordArmStateChanged ();
5448         }
5449
5450 }
5451
5452 void
5453 Session::listen_position_changed ()
5454 {
5455         boost::shared_ptr<RouteList> r = routes.reader ();
5456
5457         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5458                 (*i)->listen_position_changed ();
5459         }
5460 }
5461
5462 void
5463 Session::solo_control_mode_changed ()
5464 {
5465         /* cancel all solo or all listen when solo control mode changes */
5466
5467         if (soloing()) {
5468                 set_solo (get_routes(), false);
5469         } else if (listening()) {
5470                 set_listen (get_routes(), false);
5471         }
5472 }
5473
5474 /** Called when a property of one of our route groups changes */
5475 void
5476 Session::route_group_property_changed (RouteGroup* rg)
5477 {
5478         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
5479 }
5480
5481 /** Called when a route is added to one of our route groups */
5482 void
5483 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5484 {
5485         RouteAddedToRouteGroup (rg, r);
5486 }
5487
5488 /** Called when a route is removed from one of our route groups */
5489 void
5490 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5491 {
5492         update_route_record_state ();
5493         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
5494 }
5495
5496 boost::shared_ptr<RouteList>
5497 Session::get_tracks () const
5498 {
5499         boost::shared_ptr<RouteList> rl = routes.reader ();
5500         boost::shared_ptr<RouteList> tl (new RouteList);
5501
5502         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
5503                 if (boost::dynamic_pointer_cast<Track> (*r)) {
5504                         if (!(*r)->is_auditioner()) {
5505                                 tl->push_back (*r);
5506                         }
5507                 }
5508         }
5509         return tl;
5510 }
5511
5512 boost::shared_ptr<RouteList>
5513 Session::get_routes_with_regions_at (framepos_t const p) const
5514 {
5515         boost::shared_ptr<RouteList> r = routes.reader ();
5516         boost::shared_ptr<RouteList> rl (new RouteList);
5517
5518         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5519                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5520                 if (!tr) {
5521                         continue;
5522                 }
5523
5524                 boost::shared_ptr<Playlist> pl = tr->playlist ();
5525                 if (!pl) {
5526                         continue;
5527                 }
5528
5529                 if (pl->has_region_at (p)) {
5530                         rl->push_back (*i);
5531                 }
5532         }
5533
5534         return rl;
5535 }
5536
5537 void
5538 Session::goto_end ()
5539 {
5540         if (_session_range_location) {
5541                 request_locate (_session_range_location->end(), false);
5542         } else {
5543                 request_locate (0, false);
5544         }
5545 }
5546
5547 void
5548 Session::goto_start ()
5549 {
5550         if (_session_range_location) {
5551                 request_locate (_session_range_location->start(), false);
5552         } else {
5553                 request_locate (0, false);
5554         }
5555 }
5556
5557 framepos_t
5558 Session::current_start_frame () const
5559 {
5560         return _session_range_location ? _session_range_location->start() : 0;
5561 }
5562
5563 framepos_t
5564 Session::current_end_frame () const
5565 {
5566         return _session_range_location ? _session_range_location->end() : 0;
5567 }
5568
5569 void
5570 Session::add_session_range_location (framepos_t start, framepos_t end)
5571 {
5572         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
5573         _locations->add (_session_range_location);
5574 }
5575
5576 void
5577 Session::step_edit_status_change (bool yn)
5578 {
5579         bool send = false;
5580
5581         bool val = false;
5582         if (yn) {
5583                 send = (_step_editors == 0);
5584                 val = true;
5585
5586                 _step_editors++;
5587         } else {
5588                 send = (_step_editors == 1);
5589                 val = false;
5590
5591                 if (_step_editors > 0) {
5592                         _step_editors--;
5593                 }
5594         }
5595
5596         if (send) {
5597                 StepEditStatusChange (val);
5598         }
5599 }
5600
5601
5602 void
5603 Session::start_time_changed (framepos_t old)
5604 {
5605         /* Update the auto loop range to match the session range
5606            (unless the auto loop range has been changed by the user)
5607         */
5608
5609         Location* s = _locations->session_range_location ();
5610         if (s == 0) {
5611                 return;
5612         }
5613
5614         Location* l = _locations->auto_loop_location ();
5615
5616         if (l && l->start() == old) {
5617                 l->set_start (s->start(), true);
5618         }
5619 }
5620
5621 void
5622 Session::end_time_changed (framepos_t old)
5623 {
5624         /* Update the auto loop range to match the session range
5625            (unless the auto loop range has been changed by the user)
5626         */
5627
5628         Location* s = _locations->session_range_location ();
5629         if (s == 0) {
5630                 return;
5631         }
5632
5633         Location* l = _locations->auto_loop_location ();
5634
5635         if (l && l->end() == old) {
5636                 l->set_end (s->end(), true);
5637         }
5638 }
5639
5640 std::vector<std::string>
5641 Session::source_search_path (DataType type) const
5642 {
5643         Searchpath sp;
5644
5645         if (session_dirs.size() == 1) {
5646                 switch (type) {
5647                 case DataType::AUDIO:
5648                         sp.push_back (_session_dir->sound_path());
5649                         break;
5650                 case DataType::MIDI:
5651                         sp.push_back (_session_dir->midi_path());
5652                         break;
5653                 }
5654         } else {
5655                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5656                         SessionDirectory sdir (i->path);
5657                         switch (type) {
5658                         case DataType::AUDIO:
5659                                 sp.push_back (sdir.sound_path());
5660                                 break;
5661                         case DataType::MIDI:
5662                                 sp.push_back (sdir.midi_path());
5663                                 break;
5664                         }
5665                 }
5666         }
5667
5668         if (type == DataType::AUDIO) {
5669                 const string sound_path_2X = _session_dir->sound_path_2X();
5670                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
5671                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
5672                                 sp.push_back (sound_path_2X);
5673                         }
5674                 }
5675         }
5676
5677         // now check the explicit (possibly user-specified) search path
5678
5679         switch (type) {
5680         case DataType::AUDIO:
5681                 sp += Searchpath(config.get_audio_search_path ());
5682                 break;
5683         case DataType::MIDI:
5684                 sp += Searchpath(config.get_midi_search_path ());
5685                 break;
5686         }
5687
5688         return sp;
5689 }
5690
5691 void
5692 Session::ensure_search_path_includes (const string& path, DataType type)
5693 {
5694         Searchpath sp;
5695
5696         if (path == ".") {
5697                 return;
5698         }
5699
5700         switch (type) {
5701         case DataType::AUDIO:
5702                 sp += Searchpath(config.get_audio_search_path ());
5703                 break;
5704         case DataType::MIDI:
5705                 sp += Searchpath (config.get_midi_search_path ());
5706                 break;
5707         }
5708
5709         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5710                 /* No need to add this new directory if it has the same inode as
5711                    an existing one; checking inode rather than name prevents duplicated
5712                    directories when we are using symlinks.
5713
5714                    On Windows, I think we could just do if (*i == path) here.
5715                 */
5716                 if (PBD::equivalent_paths (*i, path)) {
5717                         return;
5718                 }
5719         }
5720
5721         sp += path;
5722
5723         switch (type) {
5724         case DataType::AUDIO:
5725                 config.set_audio_search_path (sp.to_string());
5726                 break;
5727         case DataType::MIDI:
5728                 config.set_midi_search_path (sp.to_string());
5729                 break;
5730         }
5731 }
5732
5733 void
5734 Session::remove_dir_from_search_path (const string& dir, DataType type)
5735 {
5736         Searchpath sp;
5737
5738         switch (type) {
5739         case DataType::AUDIO:
5740                 sp = Searchpath(config.get_audio_search_path ());
5741                 break;
5742         case DataType::MIDI:
5743                 sp = Searchpath (config.get_midi_search_path ());
5744                 break;
5745         }
5746
5747         sp -= dir;
5748
5749         switch (type) {
5750         case DataType::AUDIO:
5751                 config.set_audio_search_path (sp.to_string());
5752                 break;
5753         case DataType::MIDI:
5754                 config.set_midi_search_path (sp.to_string());
5755                 break;
5756         }
5757
5758 }
5759
5760 boost::shared_ptr<Speakers>
5761 Session::get_speakers()
5762 {
5763         return _speakers;
5764 }
5765
5766 list<string>
5767 Session::unknown_processors () const
5768 {
5769         list<string> p;
5770
5771         boost::shared_ptr<RouteList> r = routes.reader ();
5772         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5773                 list<string> t = (*i)->unknown_processors ();
5774                 copy (t.begin(), t.end(), back_inserter (p));
5775         }
5776
5777         p.sort ();
5778         p.unique ();
5779
5780         return p;
5781 }
5782
5783 void
5784 Session::update_latency (bool playback)
5785 {
5786         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
5787
5788         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
5789                 return;
5790         }
5791
5792         boost::shared_ptr<RouteList> r = routes.reader ();
5793         framecnt_t max_latency = 0;
5794
5795         if (playback) {
5796                 /* reverse the list so that we work backwards from the last route to run to the first */
5797                 RouteList* rl = routes.reader().get();
5798                 r.reset (new RouteList (*rl));
5799                 reverse (r->begin(), r->end());
5800         }
5801
5802         /* compute actual latency values for the given direction and store them all in per-port
5803            structures. this will also publish the same values (to JACK) so that computation of latency
5804            for routes can consistently use public latency values.
5805         */
5806
5807         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5808                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
5809         }
5810
5811         /* because we latency compensate playback, our published playback latencies should
5812            be the same for all output ports - all material played back by ardour has
5813            the same latency, whether its caused by plugins or by latency compensation. since
5814            these may differ from the values computed above, reset all playback port latencies
5815            to the same value.
5816         */
5817
5818         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
5819
5820         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5821                 (*i)->set_public_port_latencies (max_latency, playback);
5822         }
5823
5824         if (playback) {
5825
5826                 post_playback_latency ();
5827
5828         } else {
5829
5830                 post_capture_latency ();
5831         }
5832
5833         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
5834 }
5835
5836 void
5837 Session::post_playback_latency ()
5838 {
5839         set_worst_playback_latency ();
5840
5841         boost::shared_ptr<RouteList> r = routes.reader ();
5842
5843         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5844                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5845                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
5846                 }
5847         }
5848
5849         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5850                 (*i)->set_latency_compensation (_worst_track_latency);
5851         }
5852 }
5853
5854 void
5855 Session::post_capture_latency ()
5856 {
5857         set_worst_capture_latency ();
5858
5859         /* reflect any changes in capture latencies into capture offsets
5860          */
5861
5862         boost::shared_ptr<RouteList> rl = routes.reader();
5863         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5864                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5865                 if (tr) {
5866                         tr->set_capture_offset ();
5867                 }
5868         }
5869 }
5870
5871 void
5872 Session::initialize_latencies ()
5873 {
5874         {
5875                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5876                 update_latency (false);
5877                 update_latency (true);
5878         }
5879
5880         set_worst_io_latencies ();
5881 }
5882
5883 void
5884 Session::set_worst_io_latencies ()
5885 {
5886         set_worst_playback_latency ();
5887         set_worst_capture_latency ();
5888 }
5889
5890 void
5891 Session::set_worst_playback_latency ()
5892 {
5893         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5894                 return;
5895         }
5896
5897         _worst_output_latency = 0;
5898
5899         if (!_engine.connected()) {
5900                 return;
5901         }
5902
5903         boost::shared_ptr<RouteList> r = routes.reader ();
5904
5905         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5906                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5907         }
5908
5909         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5910 }
5911
5912 void
5913 Session::set_worst_capture_latency ()
5914 {
5915         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5916                 return;
5917         }
5918
5919         _worst_input_latency = 0;
5920
5921         if (!_engine.connected()) {
5922                 return;
5923         }
5924
5925         boost::shared_ptr<RouteList> r = routes.reader ();
5926
5927         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5928                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
5929         }
5930
5931         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
5932 }
5933
5934 void
5935 Session::update_latency_compensation (bool force_whole_graph)
5936 {
5937         bool some_track_latency_changed = false;
5938
5939         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5940                 return;
5941         }
5942
5943         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
5944
5945         _worst_track_latency = 0;
5946
5947         boost::shared_ptr<RouteList> r = routes.reader ();
5948
5949         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5950                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5951                         framecnt_t tl;
5952                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
5953                                 some_track_latency_changed = true;
5954                         }
5955                         _worst_track_latency = max (tl, _worst_track_latency);
5956                 }
5957         }
5958
5959         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
5960                                                      (some_track_latency_changed ? "yes" : "no")));
5961
5962         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
5963
5964         if (some_track_latency_changed || force_whole_graph)  {
5965                 _engine.update_latencies ();
5966         }
5967
5968
5969         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5970                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5971                 if (!tr) {
5972                         continue;
5973                 }
5974                 tr->set_capture_offset ();
5975         }
5976 }
5977
5978 char
5979 Session::session_name_is_legal (const string& path)
5980 {
5981         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
5982
5983         for (int i = 0; illegal_chars[i]; ++i) {
5984                 if (path.find (illegal_chars[i]) != string::npos) {
5985                         return illegal_chars[i];
5986                 }
5987         }
5988
5989         return 0;
5990 }
5991
5992 uint32_t
5993 Session::next_control_id () const
5994 {
5995         int subtract = 0;
5996
5997         /* the monitor bus remote ID is in a different
5998          * "namespace" than regular routes. its existence doesn't
5999          * affect normal (low) numbered routes.
6000          */
6001
6002         if (_monitor_out) {
6003                 subtract++;
6004         }
6005
6006         return nroutes() - subtract;
6007 }
6008
6009 void
6010 Session::notify_remote_id_change ()
6011 {
6012         if (deletion_in_progress()) {
6013                 return;
6014         }
6015
6016         switch (Config->get_remote_model()) {
6017         case MixerOrdered:
6018                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
6019                 break;
6020         default:
6021                 break;
6022         }
6023
6024 #ifdef USE_TRACKS_CODE_FEATURES
6025                 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6026                  * if track order has been changed by user
6027                  */
6028                 reconnect_existing_routes(true, true);
6029 #endif
6030
6031 }
6032
6033 void
6034 Session::sync_order_keys ()
6035 {
6036         if (deletion_in_progress()) {
6037                 return;
6038         }
6039
6040         /* tell everyone that something has happened to the sort keys
6041            and let them sync up with the change(s)
6042            this will give objects that manage the sort order keys the
6043            opportunity to keep them in sync if they wish to.
6044         */
6045
6046         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
6047
6048         reassign_track_numbers();
6049
6050         Route::SyncOrderKeys (); /* EMIT SIGNAL */
6051
6052         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
6053 }
6054
6055 bool
6056 Session::operation_in_progress (GQuark op) const
6057 {
6058         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6059 }
6060
6061 boost::shared_ptr<Port>
6062 Session::ltc_input_port () const
6063 {
6064         return _ltc_input->nth (0);
6065 }
6066
6067 boost::shared_ptr<Port>
6068 Session::ltc_output_port () const
6069 {
6070         return _ltc_output->nth (0);
6071 }
6072
6073 void
6074 Session::reconnect_ltc_input ()
6075 {
6076         if (_ltc_input) {
6077
6078                 string src = Config->get_ltc_source_port();
6079
6080                 _ltc_input->disconnect (this);
6081
6082                 if (src != _("None") && !src.empty())  {
6083                         _ltc_input->nth (0)->connect (src);
6084                 }
6085         }
6086 }
6087
6088 void
6089 Session::reconnect_ltc_output ()
6090 {
6091         if (_ltc_output) {
6092
6093 #if 0
6094                 string src = Config->get_ltc_sink_port();
6095
6096                 _ltc_output->disconnect (this);
6097
6098                 if (src != _("None") && !src.empty())  {
6099                         _ltc_output->nth (0)->connect (src);
6100                 }
6101 #endif
6102         }
6103 }