libs/ardour/session.cc

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