libs/ardour/session.cc

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