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