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