libs/ardour/session.cc

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