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