libs/ardour/session.cc

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