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