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