libs/ardour/session.cc

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