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