libs/ardour/session.cc

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