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
2615         boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2616         if (scene_in_ptr) {
2617             scene_in_ptr->disconnect_all ();
2618
2619             std::vector<EngineStateController::MidiPortState> midi_port_states;
2620             EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2621
2622             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2623
2624             for (; state_iter != midi_port_states.end(); ++state_iter) {
2625                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2626                     scene_in_ptr->connect (state_iter->name);
2627                 }
2628             }
2629         }
2630
2631     } else {
2632
2633         boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2634
2635         if (scene_out_ptr ) {
2636             scene_out_ptr->disconnect_all ();
2637
2638             std::vector<EngineStateController::MidiPortState> midi_port_states;
2639             EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2640
2641             std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2642
2643             for (; state_iter != midi_port_states.end(); ++state_iter) {
2644                 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2645                     scene_out_ptr->connect (state_iter->name);
2646                 }
2647             }
2648         }
2649     }
2650 }
2651
2652 #endif
2653
2654 /** Caller must not hold process lock
2655  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2656  */
2657 list< boost::shared_ptr<AudioTrack> >
2658 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2659                           uint32_t how_many, string name_template)
2660 {
2661         char track_name[32];
2662         uint32_t track_id = 0;
2663         string port;
2664         RouteList new_routes;
2665         list<boost::shared_ptr<AudioTrack> > ret;
2666
2667         string name_pattern;
2668
2669         if (Profile->get_trx() ) {
2670                 name_pattern = "Track ";
2671         } else {
2672                 name_pattern = "Audio ";
2673         }
2674
2675         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _(name_pattern.c_str() );
2676
2677         while (how_many) {
2678
2679                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2680                         error << "cannot find name for new audio track" << endmsg;
2681                         goto failed;
2682                 }
2683
2684                 boost::shared_ptr<AudioTrack> track;
2685
2686                 try {
2687                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2688
2689                         if (track->init ()) {
2690                                 goto failed;
2691                         }
2692
2693                         track->use_new_diskstream();
2694
2695 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2696                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2697 #endif
2698                         {
2699                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2700
2701                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_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                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2710                                         error << string_compose (
2711                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2712                                                 input_channels, output_channels)
2713                                               << endmsg;
2714                                         goto failed;
2715                                 }
2716                         }
2717
2718                         if (route_group) {
2719                                 route_group->add (track);
2720                         }
2721
2722                         track->non_realtime_input_change();
2723
2724                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2725                         if (Config->get_remote_model() == UserOrdered) {
2726                                 track->set_remote_control_id (next_control_id());
2727                         }
2728
2729                         new_routes.push_back (track);
2730                         ret.push_back (track);
2731
2732                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2733                 }
2734
2735                 catch (failed_constructor &err) {
2736                         error << _("Session: could not create new audio track.") << endmsg;
2737                         goto failed;
2738                 }
2739
2740                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2741
2742                         error << pfe.what() << endmsg;
2743                         goto failed;
2744                 }
2745
2746                 --how_many;
2747         }
2748
2749   failed:
2750         if (!new_routes.empty()) {
2751                 StateProtector sp (this);
2752                 if (Profile->get_trx()) {
2753                         add_routes (new_routes, false, false, false);
2754                 } else {
2755                         add_routes (new_routes, true, true, false);
2756                 }
2757         }
2758
2759         return ret;
2760 }
2761
2762 /** Caller must not hold process lock.
2763  *  @param name_template string to use for the start of the name, or "" to use "Bus".
2764  */
2765 RouteList
2766 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2767 {
2768         char bus_name[32];
2769         uint32_t bus_id = 0;
2770         string port;
2771         RouteList ret;
2772
2773         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2774
2775         while (how_many) {
2776                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2777                         error << "cannot find name for new audio bus" << endmsg;
2778                         goto failure;
2779                 }
2780
2781                 try {
2782                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2783
2784                         if (bus->init ()) {
2785                                 goto failure;
2786                         }
2787
2788 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2789                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2790 #endif
2791                         {
2792                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2793
2794                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_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 (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2803                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2804                                                                  input_channels, output_channels)
2805                                               << endmsg;
2806                                         goto failure;
2807                                 }
2808                         }
2809
2810                         if (route_group) {
2811                                 route_group->add (bus);
2812                         }
2813                         if (Config->get_remote_model() == UserOrdered) {
2814                                 bus->set_remote_control_id (next_control_id());
2815                         }
2816
2817                         bus->add_internal_return ();
2818
2819                         ret.push_back (bus);
2820
2821                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2822
2823                         ARDOUR::GUIIdle ();
2824                 }
2825
2826
2827                 catch (failed_constructor &err) {
2828                         error << _("Session: could not create new audio route.") << endmsg;
2829                         goto failure;
2830                 }
2831
2832                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2833                         error << pfe.what() << endmsg;
2834                         goto failure;
2835                 }
2836
2837
2838                 --how_many;
2839         }
2840
2841   failure:
2842         if (!ret.empty()) {
2843                 StateProtector sp (this);
2844                 if (Profile->get_trx()) {
2845                         add_routes (ret, false, false, false);
2846                 } else {
2847                         add_routes (ret, false, true, true); // autoconnect // outputs only
2848                 }
2849         }
2850
2851         return ret;
2852
2853 }
2854
2855 RouteList
2856 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2857 {
2858         RouteList ret;
2859         uint32_t control_id;
2860         XMLTree tree;
2861         uint32_t number = 0;
2862         const uint32_t being_added = how_many;
2863
2864         if (!tree.read (template_path.c_str())) {
2865                 return ret;
2866         }
2867
2868         XMLNode* node = tree.root();
2869
2870         IO::disable_connecting ();
2871
2872         control_id = next_control_id ();
2873
2874         while (how_many) {
2875
2876                 XMLNode node_copy (*node);
2877
2878                 /* Remove IDs of everything so that new ones are used */
2879                 node_copy.remove_property_recursively (X_("id"));
2880
2881                 try {
2882                         char name[32];
2883
2884                         if (!name_base.empty()) {
2885
2886                                 /* if we're adding more than one routes, force
2887                                  * all the names of the new routes to be
2888                                  * numbered, via the final parameter.
2889                                  */
2890
2891                                 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2892                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2893                                         /*NOTREACHDE*/
2894                                 }
2895
2896                         } else {
2897
2898                                 string const route_name  = node_copy.property(X_("name"))->value ();
2899
2900                                 /* generate a new name by adding a number to the end of the template name */
2901                                 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2902                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2903                                         abort(); /*NOTREACHED*/
2904                                 }
2905                         }
2906
2907                         /* set this name in the XML description that we are about to use */
2908                         Route::set_name_in_state (node_copy, name);
2909
2910                         /* trim bitslots from listen sends so that new ones are used */
2911                         XMLNodeList children = node_copy.children ();
2912                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2913                                 if ((*i)->name() == X_("Processor")) {
2914                                         XMLProperty* role = (*i)->property (X_("role"));
2915                                         if (role && role->value() == X_("Listen")) {
2916                                                 (*i)->remove_property (X_("bitslot"));
2917                                         }
2918                                 }
2919                         }
2920
2921                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2922
2923                         if (route == 0) {
2924                                 error << _("Session: cannot create track/bus from template description") << endmsg;
2925                                 goto out;
2926                         }
2927
2928                         if (boost::dynamic_pointer_cast<Track>(route)) {
2929                                 /* force input/output change signals so that the new diskstream
2930                                    picks up the configuration of the route. During session
2931                                    loading this normally happens in a different way.
2932                                 */
2933
2934                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2935
2936                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2937                                 change.after = route->input()->n_ports();
2938                                 route->input()->changed (change, this);
2939                                 change.after = route->output()->n_ports();
2940                                 route->output()->changed (change, this);
2941                         }
2942
2943                         route->set_remote_control_id (control_id);
2944                         ++control_id;
2945
2946                         ret.push_back (route);
2947
2948                         RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2949                 }
2950
2951                 catch (failed_constructor &err) {
2952                         error << _("Session: could not create new route from template") << endmsg;
2953                         goto out;
2954                 }
2955
2956                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2957                         error << pfe.what() << endmsg;
2958                         goto out;
2959                 }
2960
2961                 --how_many;
2962         }
2963
2964   out:
2965         if (!ret.empty()) {
2966                 StateProtector sp (this);
2967                 if (Profile->get_trx()) {
2968                         add_routes (ret, false, false, false);
2969                 } else {
2970                         add_routes (ret, true, true, false);
2971                 }
2972                 IO::enable_connecting ();
2973         }
2974
2975         return ret;
2976 }
2977
2978 void
2979 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2980 {
2981         try {
2982                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2983                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2984
2985         } catch (...) {
2986                 error << _("Adding new tracks/busses failed") << endmsg;
2987         }
2988
2989         graph_reordered ();
2990
2991         update_latency (true);
2992         update_latency (false);
2993
2994         set_dirty();
2995
2996         if (save) {
2997                 save_state (_current_snapshot_name);
2998         }
2999
3000         reassign_track_numbers();
3001
3002         update_route_record_state ();
3003
3004         RouteAdded (new_routes); /* EMIT SIGNAL */
3005 }
3006
3007 void
3008 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
3009 {
3010         ChanCount existing_inputs;
3011         ChanCount existing_outputs;
3012         uint32_t order = next_control_id();
3013
3014         if (_order_hint > -1) {
3015                 order = _order_hint;
3016                 _order_hint = -1;
3017         }
3018
3019         count_existing_track_channels (existing_inputs, existing_outputs);
3020
3021         {
3022                 RCUWriter<RouteList> writer (routes);
3023                 boost::shared_ptr<RouteList> r = writer.get_copy ();
3024                 r->insert (r->end(), new_routes.begin(), new_routes.end());
3025
3026                 /* if there is no control out and we're not in the middle of loading,
3027                    resort the graph here. if there is a control out, we will resort
3028                    toward the end of this method. if we are in the middle of loading,
3029                    we will resort when done.
3030                 */
3031
3032                 if (!_monitor_out && IO::connecting_legal) {
3033                         resort_routes_using (r);
3034                 }
3035         }
3036
3037         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3038
3039                 boost::weak_ptr<Route> wpr (*x);
3040                 boost::shared_ptr<Route> r (*x);
3041
3042                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
3043                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
3044                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
3045                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
3046                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3047                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3048
3049                 if (r->is_master()) {
3050                         _master_out = r;
3051                 }
3052
3053                 if (r->is_monitor()) {
3054                         _monitor_out = r;
3055                 }
3056
3057                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3058                 if (tr) {
3059                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3060                         track_playlist_changed (boost::weak_ptr<Track> (tr));
3061                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3062
3063                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3064                         if (mt) {
3065                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3066                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3067                         }
3068                 }
3069
3070
3071                 if (input_auto_connect || output_auto_connect) {
3072                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
3073                 }
3074
3075                 /* order keys are a GUI responsibility but we need to set up
3076                    reasonable defaults because they also affect the remote control
3077                    ID in most situations.
3078                 */
3079
3080                 if (!r->has_order_key ()) {
3081                         if (r->is_auditioner()) {
3082                                 /* use an arbitrarily high value */
3083                                 r->set_order_key (UINT_MAX);
3084                         } else {
3085                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
3086                                 r->set_order_key (order);
3087                                 order++;
3088                         }
3089                 }
3090
3091                 ARDOUR::GUIIdle ();
3092         }
3093
3094         if (_monitor_out && IO::connecting_legal) {
3095                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3096
3097                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3098                         if ((*x)->is_monitor()) {
3099                                 /* relax */
3100                         } else if ((*x)->is_master()) {
3101                                         /* relax */
3102                         } else {
3103                                 (*x)->enable_monitor_send ();
3104                         }
3105                 }
3106         }
3107 }
3108
3109 void
3110 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3111 {
3112         boost::shared_ptr<RouteList> r = routes.reader ();
3113         boost::shared_ptr<Send> s;
3114
3115         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3116                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3117                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO);
3118                 }
3119         }
3120 }
3121
3122 void
3123 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3124 {
3125         boost::shared_ptr<RouteList> r = routes.reader ();
3126         boost::shared_ptr<Send> s;
3127
3128         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3129                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3130                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY);
3131                 }
3132         }
3133 }
3134
3135 void
3136 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3137 {
3138         boost::shared_ptr<RouteList> r = routes.reader ();
3139         boost::shared_ptr<Send> s;
3140
3141         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3142                 if ((s = (*i)->internal_send_for (dest)) != 0) {
3143                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
3144                 }
3145         }
3146 }
3147
3148 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3149 void
3150 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3151 {
3152         boost::shared_ptr<RouteList> r = routes.reader ();
3153         boost::shared_ptr<RouteList> t (new RouteList);
3154
3155         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3156                 /* no MIDI sends because there are no MIDI busses yet */
3157                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3158                         t->push_back (*i);
3159                 }
3160         }
3161
3162         add_internal_sends (dest, p, t);
3163 }
3164
3165 void
3166 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3167 {
3168         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3169                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3170         }
3171 }
3172
3173 void
3174 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3175 {
3176         add_internal_send (dest, sender->before_processor_for_index (index), sender);
3177 }
3178
3179 void
3180 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3181 {
3182         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3183                 return;
3184         }
3185
3186         if (!dest->internal_return()) {
3187                 dest->add_internal_return ();
3188         }
3189
3190         sender->add_aux_send (dest, before);
3191
3192         graph_reordered ();
3193 }
3194
3195
3196 void
3197 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3198 {
3199         { // RCU Writer scope
3200                 RCUWriter<RouteList> writer (routes);
3201                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3202
3203
3204                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3205
3206                         if (*iter == _master_out) {
3207                                 continue;
3208                         }
3209
3210                         (*iter)->set_solo (false, this);
3211
3212                         rs->remove (*iter);
3213
3214                         /* deleting the master out seems like a dumb
3215                            idea, but its more of a UI policy issue
3216                            than our concern.
3217                         */
3218
3219                         if (*iter == _master_out) {
3220                                 _master_out = boost::shared_ptr<Route> ();
3221                         }
3222
3223                         if (*iter == _monitor_out) {
3224                                 _monitor_out.reset ();
3225                         }
3226
3227                         update_route_solo_state ();
3228
3229                         // We need to disconnect the route's inputs and outputs
3230
3231                         (*iter)->input()->disconnect (0);
3232                         (*iter)->output()->disconnect (0);
3233
3234                         /* if the route had internal sends sending to it, remove them */
3235                         if ((*iter)->internal_return()) {
3236
3237                                 boost::shared_ptr<RouteList> r = routes.reader ();
3238                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3239                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3240                                         if (s) {
3241                                                 (*i)->remove_processor (s);
3242                                         }
3243                                 }
3244                         }
3245
3246                         /* if the monitoring section had a pointer to this route, remove it */
3247                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3248                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3249                                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3250                                 (*iter)->remove_aux_or_listen (_monitor_out);
3251                         }
3252
3253                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3254                         if (mt && mt->step_editing()) {
3255                                 if (_step_editors > 0) {
3256                                         _step_editors--;
3257                                 }
3258                         }
3259
3260                         RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3261                 }
3262
3263                 /* writer goes out of scope, forces route list update */
3264
3265         } // end of RCU Writer scope
3266
3267         update_latency_compensation ();
3268         set_dirty();
3269
3270         /* Re-sort routes to remove the graph's current references to the one that is
3271          * going away, then flush old references out of the graph.
3272          * Wave Tracks: reconnect routes
3273          */
3274
3275 #ifdef USE_TRACKS_CODE_FEATURES
3276                 reconnect_existing_routes(true, false);
3277 #else
3278                 resort_routes ();
3279 #endif
3280
3281         if (_process_graph) {
3282                 _process_graph->clear_other_chain ();
3283         }
3284
3285         /* get rid of it from the dead wood collection in the route list manager */
3286         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3287
3288         routes.flush ();
3289
3290         /* try to cause everyone to drop their references
3291          * and unregister ports from the backend
3292          */
3293         PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3294
3295         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3296                 (*iter)->drop_references ();
3297         }
3298
3299         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3300
3301         /* save the new state of the world */
3302
3303         if (save_state (_current_snapshot_name)) {
3304                 save_history (_current_snapshot_name);
3305         }
3306
3307         reassign_track_numbers();
3308         update_route_record_state ();
3309 }
3310
3311 void
3312 Session::remove_route (boost::shared_ptr<Route> route)
3313 {
3314         boost::shared_ptr<RouteList> rl (new RouteList);
3315         rl->push_back (route);
3316         remove_routes (rl);
3317 }
3318
3319 void
3320 Session::route_mute_changed (void* /*src*/)
3321 {
3322         set_dirty ();
3323 }
3324
3325 void
3326 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3327 {
3328         boost::shared_ptr<Route> route = wpr.lock();
3329         if (!route) {
3330                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3331                 return;
3332         }
3333
3334         if (route->listening_via_monitor ()) {
3335
3336                 if (Config->get_exclusive_solo()) {
3337                         /* new listen: disable all other listen */
3338                         boost::shared_ptr<RouteList> r = routes.reader ();
3339                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3340                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3341                                         continue;
3342                                 }
3343                                 (*i)->set_listen (false, this);
3344                         }
3345                 }
3346
3347                 _listen_cnt++;
3348
3349         } else if (_listen_cnt > 0) {
3350
3351                 _listen_cnt--;
3352         }
3353
3354         update_route_solo_state ();
3355 }
3356 void
3357 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3358 {
3359         boost::shared_ptr<Route> route = wpr.lock ();
3360
3361         if (!route) {
3362                 /* should not happen */
3363                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3364                 return;
3365         }
3366
3367         bool send_changed = false;
3368
3369         if (route->solo_isolated()) {
3370                 if (_solo_isolated_cnt == 0) {
3371                         send_changed = true;
3372                 }
3373                 _solo_isolated_cnt++;
3374         } else if (_solo_isolated_cnt > 0) {
3375                 _solo_isolated_cnt--;
3376                 if (_solo_isolated_cnt == 0) {
3377                         send_changed = true;
3378                 }
3379         }
3380
3381         if (send_changed) {
3382                 IsolatedChanged (); /* EMIT SIGNAL */
3383         }
3384 }
3385
3386 void
3387 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
3388 {
3389         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3390
3391         if (!self_solo_change) {
3392                 // session doesn't care about changes to soloed-by-others
3393                 return;
3394         }
3395
3396         if (solo_update_disabled) {
3397                 // We know already
3398                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
3399                 return;
3400         }
3401
3402         boost::shared_ptr<Route> route = wpr.lock ();
3403         assert (route);
3404
3405         boost::shared_ptr<RouteList> r = routes.reader ();
3406         int32_t delta;
3407
3408         if (route->self_soloed()) {
3409                 delta = 1;
3410         } else {
3411                 delta = -1;
3412         }
3413
3414         RouteGroup* rg = route->route_group ();
3415         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
3416
3417         if (delta == 1 && Config->get_exclusive_solo()) {
3418
3419                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3420
3421                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3422                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3423                             (leave_group_alone && ((*i)->route_group() == rg))) {
3424                                 continue;
3425                         }
3426                         (*i)->set_solo (false, this);
3427                 }
3428         }
3429
3430         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3431
3432         solo_update_disabled = true;
3433
3434         RouteList uninvolved;
3435
3436         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3437
3438         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3439                 bool via_sends_only;
3440                 bool in_signal_flow;
3441
3442                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3443                     (leave_group_alone && ((*i)->route_group() == rg))) {
3444                         continue;
3445                 }
3446
3447                 in_signal_flow = false;
3448
3449                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3450
3451                 if ((*i)->feeds (route, &via_sends_only)) {
3452                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3453                         if (!via_sends_only) {
3454                                 if (!route->soloed_by_others_upstream()) {
3455                                         (*i)->mod_solo_by_others_downstream (delta);
3456                                 }
3457                         } else {
3458                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3459                         }
3460                         in_signal_flow = true;
3461                 } else {
3462                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3463                 }
3464
3465                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3466
3467                 if (route->feeds (*i, &via_sends_only)) {
3468                         /* propagate solo upstream only if routing other than
3469                            sends is involved, but do consider the other route
3470                            (*i) to be part of the signal flow even if only
3471                            sends are involved.
3472                         */
3473                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3474                                                                   route->name(),
3475                                                                   (*i)->name(),
3476                                                                   via_sends_only,
3477                                                                   route->soloed_by_others_downstream(),
3478                                                                   route->soloed_by_others_upstream()));
3479                         if (!via_sends_only) {
3480                                 if (!route->soloed_by_others_downstream()) {
3481                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3482                                         (*i)->mod_solo_by_others_upstream (delta);
3483                                 } else {
3484                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
3485                                 }
3486                         } else {
3487                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3488                         }
3489                         in_signal_flow = true;
3490                 } else {
3491                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3492                 }
3493
3494                 if (!in_signal_flow) {
3495                         uninvolved.push_back (*i);
3496                 }
3497         }
3498
3499         solo_update_disabled = false;
3500         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3501
3502         update_route_solo_state (r);
3503
3504         /* now notify that the mute state of the routes not involved in the signal
3505            pathway of the just-solo-changed route may have altered.
3506         */
3507
3508         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3509                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3510                 (*i)->act_on_mute ();
3511                 (*i)->mute_changed (this);
3512         }
3513
3514         SoloChanged (); /* EMIT SIGNAL */
3515         set_dirty();
3516 }
3517
3518 void
3519 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3520 {
3521         /* now figure out if anything that matters is soloed (or is "listening")*/
3522
3523         bool something_soloed = false;
3524         uint32_t listeners = 0;
3525         uint32_t isolated = 0;
3526
3527         if (!r) {
3528                 r = routes.reader();
3529         }
3530
3531         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3532                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3533                         something_soloed = true;
3534                 }
3535
3536                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3537                         if (Config->get_solo_control_is_listen_control()) {
3538                                 listeners++;
3539                         } else {
3540                                 (*i)->set_listen (false, this);
3541                         }
3542                 }
3543
3544                 if ((*i)->solo_isolated()) {
3545                         isolated++;
3546                 }
3547         }
3548
3549         if (something_soloed != _non_soloed_outs_muted) {
3550                 _non_soloed_outs_muted = something_soloed;
3551                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3552         }
3553
3554         _listen_cnt = listeners;
3555
3556         if (isolated != _solo_isolated_cnt) {
3557                 _solo_isolated_cnt = isolated;
3558                 IsolatedChanged (); /* EMIT SIGNAL */
3559         }
3560
3561         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3562                                                   something_soloed, listeners, isolated));
3563 }
3564
3565 boost::shared_ptr<RouteList>
3566 Session::get_routes_with_internal_returns() const
3567 {
3568         boost::shared_ptr<RouteList> r = routes.reader ();
3569         boost::shared_ptr<RouteList> rl (new RouteList);
3570
3571         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3572                 if ((*i)->internal_return ()) {
3573                         rl->push_back (*i);
3574                 }
3575         }
3576         return rl;
3577 }
3578
3579 bool
3580 Session::io_name_is_legal (const std::string& name)
3581 {
3582         boost::shared_ptr<RouteList> r = routes.reader ();
3583
3584         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3585                 if ((*i)->name() == name) {
3586                         return false;
3587                 }
3588
3589                 if ((*i)->has_io_processor_named (name)) {
3590                         return false;
3591                 }
3592         }
3593
3594         return true;
3595 }
3596
3597 void
3598 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
3599 {
3600         RouteList rl2;
3601         vector<string> connections;
3602
3603         /* if we are passed only a single route and we're not told to turn
3604          * others off, then just do the simple thing.
3605          */
3606
3607         if (flip_others == false && rl->size() == 1) {
3608                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
3609                 if (mt) {
3610                         mt->set_input_active (onoff);
3611                         return;
3612                 }
3613         }
3614
3615         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
3616
3617                 PortSet& ps ((*rt)->input()->ports());
3618
3619                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
3620                         p->get_connections (connections);
3621                 }
3622
3623                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
3624                         routes_using_input_from (*s, rl2);
3625                 }
3626
3627                 /* scan all relevant routes to see if others are on or off */
3628
3629                 bool others_are_already_on = false;
3630
3631                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3632
3633                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3634
3635                         if (!mt) {
3636                                 continue;
3637                         }
3638
3639                         if ((*r) != (*rt)) {
3640                                 if (mt->input_active()) {
3641                                         others_are_already_on = true;
3642                                 }
3643                         } else {
3644                                 /* this one needs changing */
3645                                 mt->set_input_active (onoff);
3646                         }
3647                 }
3648
3649                 if (flip_others) {
3650
3651                         /* globally reverse other routes */
3652
3653                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3654                                 if ((*r) != (*rt)) {
3655                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3656                                         if (mt) {
3657                                                 mt->set_input_active (!others_are_already_on);
3658                                         }
3659                                 }
3660                         }
3661                 }
3662         }
3663 }
3664
3665 void
3666 Session::routes_using_input_from (const string& str, RouteList& rl)
3667 {
3668         boost::shared_ptr<RouteList> r = routes.reader();
3669
3670         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3671                 if ((*i)->input()->connected_to (str)) {
3672                         rl.push_back (*i);
3673                 }
3674         }
3675 }
3676
3677 boost::shared_ptr<Route>
3678 Session::route_by_name (string name)
3679 {
3680         boost::shared_ptr<RouteList> r = routes.reader ();
3681
3682         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3683                 if ((*i)->name() == name) {
3684                         return *i;
3685                 }
3686         }
3687
3688         return boost::shared_ptr<Route> ((Route*) 0);
3689 }
3690
3691 boost::shared_ptr<Route>
3692 Session::route_by_id (PBD::ID id)
3693 {
3694         boost::shared_ptr<RouteList> r = routes.reader ();
3695
3696         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3697                 if ((*i)->id() == id) {
3698                         return *i;
3699                 }
3700         }
3701
3702         return boost::shared_ptr<Route> ((Route*) 0);
3703 }
3704
3705 boost::shared_ptr<Track>
3706 Session::track_by_diskstream_id (PBD::ID id)
3707 {
3708         boost::shared_ptr<RouteList> r = routes.reader ();
3709
3710         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3711                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3712                 if (t && t->using_diskstream_id (id)) {
3713                         return t;
3714                 }
3715         }
3716
3717         return boost::shared_ptr<Track> ();
3718 }
3719
3720 boost::shared_ptr<Route>
3721 Session::route_by_remote_id (uint32_t id)
3722 {
3723         boost::shared_ptr<RouteList> r = routes.reader ();
3724
3725         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3726                 if ((*i)->remote_control_id() == id) {
3727                         return *i;
3728                 }
3729         }
3730
3731         return boost::shared_ptr<Route> ((Route*) 0);
3732 }
3733
3734
3735 void
3736 Session::reassign_track_numbers ()
3737 {
3738         int64_t tn = 0;
3739         int64_t bn = 0;
3740         RouteList r (*(routes.reader ()));
3741         SignalOrderRouteSorter sorter;
3742         r.sort (sorter);
3743
3744         StateProtector sp (this);
3745
3746         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3747                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3748                         (*i)->set_track_number(++tn);
3749                 }
3750                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
3751                         (*i)->set_track_number(--bn);
3752                 }
3753         }
3754         const uint32_t decimals = ceilf (log10f (tn + 1));
3755         const bool decimals_changed = _track_number_decimals != decimals;
3756         _track_number_decimals = decimals;
3757
3758         if (decimals_changed && config.get_track_name_number ()) {
3759                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3760                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3761                         if (t) {
3762                                 t->resync_track_name();
3763                         }
3764                 }
3765                 // trigger GUI re-layout
3766                 config.ParameterChanged("track-name-number");
3767         }
3768 }
3769
3770 void
3771 Session::playlist_region_added (boost::weak_ptr<Region> w)
3772 {
3773         boost::shared_ptr<Region> r = w.lock ();
3774         if (!r) {
3775                 return;
3776         }
3777
3778         /* These are the operations that are currently in progress... */
3779         list<GQuark> curr = _current_trans_quarks;
3780         curr.sort ();
3781
3782         /* ...and these are the operations during which we want to update
3783            the session range location markers.
3784         */
3785         list<GQuark> ops;
3786         ops.push_back (Operations::capture);
3787         ops.push_back (Operations::paste);
3788         ops.push_back (Operations::duplicate_region);
3789         ops.push_back (Operations::insert_file);
3790         ops.push_back (Operations::insert_region);
3791         ops.push_back (Operations::drag_region_brush);
3792         ops.push_back (Operations::region_drag);
3793         ops.push_back (Operations::selection_grab);
3794         ops.push_back (Operations::region_fill);
3795         ops.push_back (Operations::fill_selection);
3796         ops.push_back (Operations::create_region);
3797         ops.push_back (Operations::region_copy);
3798         ops.push_back (Operations::fixed_time_region_copy);
3799         ops.sort ();
3800
3801         /* See if any of the current operations match the ones that we want */
3802         list<GQuark> in;
3803         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3804
3805         /* If so, update the session range markers */
3806         if (!in.empty ()) {
3807                 maybe_update_session_range (r->position (), r->last_frame ());
3808         }
3809 }
3810
3811 /** Update the session range markers if a is before the current start or
3812  *  b is after the current end.
3813  */
3814 void
3815 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3816 {
3817         if (_state_of_the_state & Loading) {
3818                 return;
3819         }
3820
3821         if (_session_range_location == 0) {
3822
3823                 add_session_range_location (a, b);
3824
3825         } else {
3826
3827                 if (a < _session_range_location->start()) {
3828                         _session_range_location->set_start (a);
3829                 }
3830
3831                 if (b > _session_range_location->end()) {
3832                         _session_range_location->set_end (b);
3833                 }
3834         }
3835 }
3836
3837 void
3838 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3839 {
3840         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3841                 maybe_update_session_range (i->to, i->to + i->length);
3842         }
3843 }
3844
3845 void
3846 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3847 {
3848         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3849                 maybe_update_session_range (i->from, i->to);
3850         }
3851 }
3852
3853 /* Region management */
3854
3855 boost::shared_ptr<Region>
3856 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3857 {
3858         const RegionFactory::RegionMap& regions (RegionFactory::regions());
3859         RegionFactory::RegionMap::const_iterator i;
3860         boost::shared_ptr<Region> region;
3861
3862         Glib::Threads::Mutex::Lock lm (region_lock);
3863
3864         for (i = regions.begin(); i != regions.end(); ++i) {
3865
3866                 region = i->second;
3867
3868                 if (region->whole_file()) {
3869
3870                         if (child->source_equivalent (region)) {
3871                                 return region;
3872                         }
3873                 }
3874         }
3875
3876         return boost::shared_ptr<Region> ();
3877 }
3878
3879 int
3880 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3881 {
3882         set<boost::shared_ptr<Region> > relevant_regions;
3883
3884         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3885                 RegionFactory::get_regions_using_source (*s, relevant_regions);
3886         }
3887
3888         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3889                 set<boost::shared_ptr<Region> >::iterator tmp;
3890
3891                 tmp = r;
3892                 ++tmp;
3893
3894                 playlists->destroy_region (*r);
3895                 RegionFactory::map_remove (*r);
3896
3897                 (*r)->drop_sources ();
3898                 (*r)->drop_references ();
3899
3900                 relevant_regions.erase (r);
3901
3902                 r = tmp;
3903         }
3904
3905         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3906
3907                 {
3908                         Glib::Threads::Mutex::Lock ls (source_lock);
3909                         /* remove from the main source list */
3910                         sources.erase ((*s)->id());
3911                 }
3912
3913                 (*s)->mark_for_remove ();
3914                 (*s)->drop_references ();
3915
3916                 s = srcs.erase (s);
3917         }
3918
3919         return 0;
3920 }
3921
3922 int
3923 Session::remove_last_capture ()
3924 {
3925         list<boost::shared_ptr<Source> > srcs;
3926
3927         boost::shared_ptr<RouteList> rl = routes.reader ();
3928         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3929                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3930                 if (!tr) {
3931                         continue;
3932                 }
3933
3934                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3935
3936                 if (!l.empty()) {
3937                         srcs.insert (srcs.end(), l.begin(), l.end());
3938                         l.clear ();
3939                 }
3940         }
3941
3942         destroy_sources (srcs);
3943
3944         save_state (_current_snapshot_name);
3945
3946         return 0;
3947 }
3948
3949 /* Source Management */
3950
3951 void
3952 Session::add_source (boost::shared_ptr<Source> source)
3953 {
3954         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3955         pair<SourceMap::iterator,bool> result;
3956
3957         entry.first = source->id();
3958         entry.second = source;
3959
3960         {
3961                 Glib::Threads::Mutex::Lock lm (source_lock);
3962                 result = sources.insert (entry);
3963         }
3964
3965         if (result.second) {
3966
3967                 /* yay, new source */
3968
3969                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3970
3971                 if (fs) {
3972                         if (!fs->within_session()) {
3973                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3974                         }
3975                 }
3976
3977                 set_dirty();
3978
3979                 boost::shared_ptr<AudioFileSource> afs;
3980
3981                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3982                         if (Config->get_auto_analyse_audio()) {
3983                                 Analyser::queue_source_for_analysis (source, false);
3984                         }
3985                 }
3986
3987                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3988         }
3989 }
3990
3991 void
3992 Session::remove_source (boost::weak_ptr<Source> src)
3993 {
3994         if (_state_of_the_state & Deletion) {
3995                 return;
3996         }
3997
3998         SourceMap::iterator i;
3999         boost::shared_ptr<Source> source = src.lock();
4000
4001         if (!source) {
4002                 return;
4003         }
4004
4005         {
4006                 Glib::Threads::Mutex::Lock lm (source_lock);
4007
4008                 if ((i = sources.find (source->id())) != sources.end()) {
4009                         sources.erase (i);
4010                 }
4011         }
4012
4013         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4014
4015                 /* save state so we don't end up with a session file
4016                    referring to non-existent sources.
4017                 */
4018
4019                 save_state (_current_snapshot_name);
4020         }
4021 }
4022
4023 boost::shared_ptr<Source>
4024 Session::source_by_id (const PBD::ID& id)
4025 {
4026         Glib::Threads::Mutex::Lock lm (source_lock);
4027         SourceMap::iterator i;
4028         boost::shared_ptr<Source> source;
4029
4030         if ((i = sources.find (id)) != sources.end()) {
4031                 source = i->second;
4032         }
4033
4034         return source;
4035 }
4036
4037 boost::shared_ptr<AudioFileSource>
4038 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4039 {
4040         /* Restricted to audio files because only audio sources have channel
4041            as a property.
4042         */
4043
4044         Glib::Threads::Mutex::Lock lm (source_lock);
4045
4046         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4047                 boost::shared_ptr<AudioFileSource> afs
4048                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4049
4050                 if (afs && afs->path() == path && chn == afs->channel()) {
4051                         return afs;
4052                 }
4053         }
4054
4055         return boost::shared_ptr<AudioFileSource>();
4056 }
4057
4058 boost::shared_ptr<MidiSource>
4059 Session::midi_source_by_path (const std::string& path) const
4060 {
4061         /* Restricted to MIDI files because audio sources require a channel
4062            for unique identification, in addition to a path.
4063         */
4064
4065         Glib::Threads::Mutex::Lock lm (source_lock);
4066
4067         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4068                 boost::shared_ptr<MidiSource> ms
4069                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
4070                 boost::shared_ptr<FileSource> fs
4071                         = boost::dynamic_pointer_cast<FileSource>(s->second);
4072
4073                 if (ms && fs && fs->path() == path) {
4074                         return ms;
4075                 }
4076         }
4077
4078         return boost::shared_ptr<MidiSource>();
4079 }
4080
4081 uint32_t
4082 Session::count_sources_by_origin (const string& path)
4083 {
4084         uint32_t cnt = 0;
4085         Glib::Threads::Mutex::Lock lm (source_lock);
4086
4087         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4088                 boost::shared_ptr<FileSource> fs
4089                         = boost::dynamic_pointer_cast<FileSource>(i->second);
4090
4091                 if (fs && fs->origin() == path) {
4092                         ++cnt;
4093                 }
4094         }
4095
4096         return cnt;
4097 }
4098
4099 string
4100 Session::peak_path (string base) const
4101 {
4102         if (Glib::path_is_absolute (base)) {
4103
4104                 /* rip the session dir from the audiofile source */
4105
4106                 string session_path;
4107                 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4108                 bool in_another_session = true;
4109
4110                 if (base.find (interchange_dir_string) != string::npos) {
4111
4112                         session_path = Glib::path_get_dirname (base); /* now ends in audiofiles */
4113                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4114                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4115                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
4116
4117                         /* see if it is within our session */
4118
4119                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4120                                 if (i->path == session_path) {
4121                                         in_another_session = false;
4122                                         break;
4123                                 }
4124                         }
4125                 } else {
4126                         in_another_session = false;
4127                 }
4128
4129
4130                 if (in_another_session) {
4131                         SessionDirectory sd (session_path);
4132                         return Glib::build_filename (sd.peak_path(), Glib::path_get_basename (base) + peakfile_suffix);
4133                 }
4134         }
4135
4136         base = Glib::path_get_basename (base);
4137         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
4138 }
4139
4140 string
4141 Session::new_audio_source_path_for_embedded (const std::string& path)
4142 {
4143         /* embedded source:
4144          *
4145          * we know that the filename is already unique because it exists
4146          * out in the filesystem.
4147          *
4148          * However, when we bring it into the session, we could get a
4149          * collision.
4150          *
4151          * Eg. two embedded files:
4152          *
4153          *          /foo/bar/baz.wav
4154          *          /frob/nic/baz.wav
4155          *
4156          * When merged into session, these collide.
4157          *
4158          * There will not be a conflict with in-memory sources
4159          * because when the source was created we already picked
4160          * a unique name for it.
4161          *
4162          * This collision is not likely to be common, but we have to guard
4163          * against it.  So, if there is a collision, take the md5 hash of the
4164          * the path, and use that as the filename instead.
4165          */
4166
4167         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4168         string base = Glib::path_get_basename (path);
4169         string newpath = Glib::build_filename (sdir.sound_path(), base);
4170
4171         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4172
4173                 MD5 md5;
4174
4175                 md5.digestString (path.c_str());
4176                 md5.writeToString ();
4177                 base = md5.digestChars;
4178
4179                 string ext = get_suffix (path);
4180
4181                 if (!ext.empty()) {
4182                         base += '.';
4183                         base += ext;
4184                 }
4185
4186                 newpath = Glib::build_filename (sdir.sound_path(), base);
4187
4188                 /* if this collides, we're screwed */
4189
4190                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4191                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4192                         return string();
4193                 }
4194
4195         }
4196
4197         return newpath;
4198 }
4199
4200 /** Return true if there are no audio file sources that use @param name as
4201  * the filename component of their path.
4202  *
4203  * Return false otherwise.
4204  *
4205  * This method MUST ONLY be used to check in-session, mono files since it
4206  * hard-codes the channel of the audio file source we are looking for as zero.
4207  *
4208  * If/when Ardour supports native files in non-mono formats, the logic here
4209  * will need to be revisited.
4210  */
4211 bool
4212 Session::audio_source_name_is_unique (const string& name)
4213 {
4214         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4215         vector<space_and_path>::iterator i;
4216         uint32_t existing = 0;
4217
4218         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4219
4220                 /* note that we search *without* the extension so that
4221                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4222                    in the event that this new name is required for
4223                    a file format change.
4224                 */
4225
4226                 const string spath = *i;
4227
4228                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4229                         existing++;
4230                         break;
4231                 }
4232
4233                 /* it is possible that we have the path already
4234                  * assigned to a source that has not yet been written
4235                  * (ie. the write source for a diskstream). we have to
4236                  * check this in order to make sure that our candidate
4237                  * path isn't used again, because that can lead to
4238                  * two Sources point to the same file with different
4239                  * notions of their removability.
4240                  */
4241
4242
4243                 string possible_path = Glib::build_filename (spath, name);
4244
4245                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4246                         existing++;
4247                         break;
4248                 }
4249         }
4250
4251         return (existing == 0);
4252 }
4253
4254 string
4255 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)
4256 {
4257         ostringstream sstr;
4258         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4259
4260         if (destructive) {
4261                 sstr << 'T';
4262                 sstr << setfill ('0') << setw (4) << cnt;
4263                 sstr << legalized_base;
4264         } else {
4265                 sstr << legalized_base;
4266
4267                 if (take_required || related_exists) {
4268                         sstr << '-';
4269                         sstr << cnt;
4270                 }
4271         }
4272
4273         if (nchan == 2) {
4274                 if (chan == 0) {
4275                         sstr << "%L";
4276                 } else {
4277                         sstr << "%R";
4278                 }
4279         } else if (nchan > 2) {
4280                 if (nchan < 26) {
4281                         sstr << '%';
4282                         sstr << 'a' + chan;
4283                 } else {
4284                         /* XXX what? more than 26 channels! */
4285                         sstr << '%';
4286                         sstr << chan+1;
4287                 }
4288         }
4289
4290         sstr << ext;
4291
4292         return sstr.str();
4293 }
4294
4295 /** Return a unique name based on \a base for a new internal audio source */
4296 string
4297 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4298 {
4299         uint32_t cnt;
4300         string possible_name;
4301         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4302         string legalized;
4303         bool some_related_source_name_exists = false;
4304
4305         legalized = legalize_for_path (base);
4306
4307         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4308
4309         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4310
4311                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4312
4313                 if (audio_source_name_is_unique (possible_name)) {
4314                         break;
4315                 }
4316
4317                 some_related_source_name_exists = true;
4318
4319                 if (cnt > limit) {
4320                         error << string_compose(
4321                                         _("There are already %1 recordings for %2, which I consider too many."),
4322                                         limit, base) << endmsg;
4323                         destroy ();
4324                         throw failed_constructor();
4325                 }
4326         }
4327
4328         /* We've established that the new name does not exist in any session
4329          * directory, so now find out which one we should use for this new
4330          * audio source.
4331          */
4332
4333         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4334
4335         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4336
4337         return s;
4338 }
4339
4340 /** Return a unique name based on `base` for a new internal MIDI source */
4341 string
4342 Session::new_midi_source_path (const string& base)
4343 {
4344         uint32_t cnt;
4345         char buf[PATH_MAX+1];
4346         const uint32_t limit = 10000;
4347         string legalized;
4348         string possible_path;
4349         string possible_name;
4350
4351         buf[0] = '\0';
4352         legalized = legalize_for_path (base);
4353
4354         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4355         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4356
4357         /* - the main session folder is the first in the vector.
4358          * - after checking all locations for file-name uniqueness,
4359          *   we keep the one from the last iteration as new file name
4360          * - midi files are small and should just be kept in the main session-folder
4361          *
4362          * -> reverse the array, check main session folder last and use that as location
4363          *    for MIDI files.
4364          */
4365         std::reverse(sdirs.begin(), sdirs.end());
4366
4367         for (cnt = 1; cnt <= limit; ++cnt) {
4368
4369                 vector<space_and_path>::iterator i;
4370                 uint32_t existing = 0;
4371
4372                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4373
4374                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4375                         possible_name = buf;
4376
4377                         possible_path = Glib::build_filename (*i, possible_name);
4378
4379                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4380                                 existing++;
4381                         }
4382
4383                         if (midi_source_by_path (possible_path)) {
4384                                 existing++;
4385                         }
4386                 }
4387
4388                 if (existing == 0) {
4389                         break;
4390                 }
4391
4392                 if (cnt > limit) {
4393                         error << string_compose(
4394                                         _("There are already %1 recordings for %2, which I consider too many."),
4395                                         limit, base) << endmsg;
4396                         destroy ();
4397                         return 0;
4398                 }
4399         }
4400
4401         /* No need to "find best location" for software/app-based RAID, because
4402            MIDI is so small that we always put it in the same place.
4403         */
4404
4405         return possible_path;
4406 }
4407
4408
4409 /** Create a new within-session audio source */
4410 boost::shared_ptr<AudioFileSource>
4411 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4412 {
4413         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4414
4415         if (!path.empty()) {
4416                 return boost::dynamic_pointer_cast<AudioFileSource> (
4417                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
4418         } else {
4419                 throw failed_constructor ();
4420         }
4421 }
4422
4423 /** Create a new within-session MIDI source */
4424 boost::shared_ptr<MidiSource>
4425 Session::create_midi_source_for_session (string const & basic_name)
4426 {
4427         const string path = new_midi_source_path (basic_name);
4428
4429         if (!path.empty()) {
4430                 return boost::dynamic_pointer_cast<SMFSource> (
4431                         SourceFactory::createWritable (
4432                                 DataType::MIDI, *this, path, false, frame_rate()));
4433         } else {
4434                 throw failed_constructor ();
4435         }
4436 }
4437
4438 /** Create a new within-session MIDI source */
4439 boost::shared_ptr<MidiSource>
4440 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4441 {
4442         /* the caller passes in the track the source will be used in,
4443            so that we can keep the numbering sane.
4444
4445            Rationale: a track with the name "Foo" that has had N
4446            captures carried out so far will ALREADY have a write source
4447            named "Foo-N+1.mid" waiting to be used for the next capture.
4448
4449            If we call new_midi_source_name() we will get "Foo-N+2". But
4450            there is no region corresponding to "Foo-N+1", so when
4451            "Foo-N+2" appears in the track, the gap presents the user
4452            with odd behaviour - why did it skip past Foo-N+1?
4453
4454            We could explain this to the user in some odd way, but
4455            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4456            use "Foo-N+1" here.
4457
4458            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4459         */
4460
4461         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4462         assert (mt);
4463         std::string name = track->steal_write_source_name ();
4464
4465         if (name.empty()) {
4466                 return boost::shared_ptr<MidiSource>();
4467         }
4468
4469         /* MIDI files are small, just put them in the first location of the
4470            session source search path.
4471         */
4472
4473         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4474
4475         return boost::dynamic_pointer_cast<SMFSource> (
4476                 SourceFactory::createWritable (
4477                         DataType::MIDI, *this, path, false, frame_rate()));
4478 }
4479
4480
4481 void
4482 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4483 {
4484         if (playlist->hidden()) {
4485                 return;
4486         }
4487
4488         playlists->add (playlist);
4489
4490         if (unused) {
4491                 playlist->release();
4492         }
4493
4494         set_dirty();
4495 }
4496
4497 void
4498 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4499 {
4500         if (_state_of_the_state & Deletion) {
4501                 return;
4502         }
4503
4504         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4505
4506         if (!playlist) {
4507                 return;
4508         }
4509
4510         playlists->remove (playlist);
4511
4512         set_dirty();
4513 }
4514
4515 void
4516 Session::set_audition (boost::shared_ptr<Region> r)
4517 {
4518         pending_audition_region = r;
4519         add_post_transport_work (PostTransportAudition);
4520         _butler->schedule_transport_work ();
4521 }
4522
4523 void
4524 Session::audition_playlist ()
4525 {
4526         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4527         ev->region.reset ();
4528         queue_event (ev);
4529 }
4530
4531 void
4532 Session::non_realtime_set_audition ()
4533 {
4534         assert (pending_audition_region);
4535         auditioner->audition_region (pending_audition_region);
4536         pending_audition_region.reset ();
4537         AuditionActive (true); /* EMIT SIGNAL */
4538 }
4539
4540 void
4541 Session::audition_region (boost::shared_ptr<Region> r)
4542 {
4543         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4544         ev->region = r;
4545         queue_event (ev);
4546 }
4547
4548 void
4549 Session::cancel_audition ()
4550 {
4551         if (!auditioner) {
4552                 return;
4553         }
4554         if (auditioner->auditioning()) {
4555                 auditioner->cancel_audition ();
4556                 AuditionActive (false); /* EMIT SIGNAL */
4557         }
4558 }
4559
4560 bool
4561 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4562 {
4563         if (a->is_monitor()) {
4564                 return true;
4565         }
4566         if (b->is_monitor()) {
4567                 return false;
4568         }
4569         return a->order_key () < b->order_key ();
4570 }
4571
4572 bool
4573 Session::is_auditioning () const
4574 {
4575         /* can be called before we have an auditioner object */
4576         if (auditioner) {
4577                 return auditioner->auditioning();
4578         } else {
4579                 return false;
4580         }
4581 }
4582
4583 void
4584 Session::graph_reordered ()
4585 {
4586         /* don't do this stuff if we are setting up connections
4587            from a set_state() call or creating new tracks. Ditto for deletion.
4588         */
4589
4590         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress) {
4591                 return;
4592         }
4593
4594         /* every track/bus asked for this to be handled but it was deferred because
4595            we were connecting. do it now.
4596         */
4597
4598         request_input_change_handling ();
4599
4600         resort_routes ();
4601
4602         /* force all diskstreams to update their capture offset values to
4603            reflect any changes in latencies within the graph.
4604         */
4605
4606         boost::shared_ptr<RouteList> rl = routes.reader ();
4607         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4608                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4609                 if (tr) {
4610                         tr->set_capture_offset ();
4611                 }
4612         }
4613 }
4614
4615 /** @return Number of frames that there is disk space available to write,
4616  *  if known.
4617  */
4618 boost::optional<framecnt_t>
4619 Session::available_capture_duration ()
4620 {
4621         Glib::Threads::Mutex::Lock lm (space_lock);
4622
4623         if (_total_free_4k_blocks_uncertain) {
4624                 return boost::optional<framecnt_t> ();
4625         }
4626
4627         float sample_bytes_on_disk = 4.0; // keep gcc happy
4628
4629         switch (config.get_native_file_data_format()) {
4630         case FormatFloat:
4631                 sample_bytes_on_disk = 4.0;
4632                 break;
4633
4634         case FormatInt24:
4635                 sample_bytes_on_disk = 3.0;
4636                 break;
4637
4638         case FormatInt16:
4639                 sample_bytes_on_disk = 2.0;
4640                 break;
4641
4642         default:
4643                 /* impossible, but keep some gcc versions happy */
4644                 fatal << string_compose (_("programming error: %1"),
4645                                          X_("illegal native file data format"))
4646                       << endmsg;
4647                 abort(); /*NOTREACHED*/
4648         }
4649
4650         double scale = 4096.0 / sample_bytes_on_disk;
4651
4652         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4653                 return max_framecnt;
4654         }
4655
4656         return (framecnt_t) floor (_total_free_4k_blocks * scale);
4657 }
4658
4659 void
4660 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
4661 {
4662         {
4663                 RCUWriter<BundleList> writer (_bundles);
4664                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4665                 b->push_back (bundle);
4666         }
4667
4668         if (emit_signal) {
4669                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
4670         }
4671
4672         set_dirty();
4673 }
4674
4675 void
4676 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
4677 {
4678         bool removed = false;
4679
4680         {
4681                 RCUWriter<BundleList> writer (_bundles);
4682                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4683                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
4684
4685                 if (i != b->end()) {
4686                         b->erase (i);
4687                         removed = true;
4688                 }
4689         }
4690
4691         if (removed) {
4692                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
4693         }
4694
4695         set_dirty();
4696 }
4697
4698 boost::shared_ptr<Bundle>
4699 Session::bundle_by_name (string name) const
4700 {
4701         boost::shared_ptr<BundleList> b = _bundles.reader ();
4702
4703         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
4704                 if ((*i)->name() == name) {
4705                         return* i;
4706                 }
4707         }
4708
4709         return boost::shared_ptr<Bundle> ();
4710 }
4711
4712 void
4713 Session::tempo_map_changed (const PropertyChange&)
4714 {
4715         clear_clicks ();
4716
4717         playlists->update_after_tempo_map_change ();
4718
4719         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4720
4721         set_dirty ();
4722 }
4723
4724 void
4725 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
4726 {
4727         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
4728                 (*i)->recompute_frames_from_bbt ();
4729         }
4730 }
4731
4732 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4733  * the given count with the current block size.
4734  */
4735 void
4736 Session::ensure_buffers (ChanCount howmany)
4737 {
4738         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4739 }
4740
4741 void
4742 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4743 {
4744         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4745                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4746         }
4747 }
4748
4749 uint32_t
4750 Session::next_insert_id ()
4751 {
4752         /* this doesn't really loop forever. just think about it */
4753
4754         while (true) {
4755                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4756                         if (!insert_bitset[n]) {
4757                                 insert_bitset[n] = true;
4758                                 return n;
4759
4760                         }
4761                 }
4762
4763                 /* none available, so resize and try again */
4764
4765                 insert_bitset.resize (insert_bitset.size() + 16, false);
4766         }
4767 }
4768
4769 uint32_t
4770 Session::next_send_id ()
4771 {
4772         /* this doesn't really loop forever. just think about it */
4773
4774         while (true) {
4775                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4776                         if (!send_bitset[n]) {
4777                                 send_bitset[n] = true;
4778                                 return n;
4779
4780                         }
4781                 }
4782
4783                 /* none available, so resize and try again */
4784
4785                 send_bitset.resize (send_bitset.size() + 16, false);
4786         }
4787 }
4788
4789 uint32_t
4790 Session::next_aux_send_id ()
4791 {
4792         /* this doesn't really loop forever. just think about it */
4793
4794         while (true) {
4795                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4796                         if (!aux_send_bitset[n]) {
4797                                 aux_send_bitset[n] = true;
4798                                 return n;
4799
4800                         }
4801                 }
4802
4803                 /* none available, so resize and try again */
4804
4805                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4806         }
4807 }
4808
4809 uint32_t
4810 Session::next_return_id ()
4811 {
4812         /* this doesn't really loop forever. just think about it */
4813
4814         while (true) {
4815                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
4816                         if (!return_bitset[n]) {
4817                                 return_bitset[n] = true;
4818                                 return n;
4819
4820                         }
4821                 }
4822
4823                 /* none available, so resize and try again */
4824
4825                 return_bitset.resize (return_bitset.size() + 16, false);
4826         }
4827 }
4828
4829 void
4830 Session::mark_send_id (uint32_t id)
4831 {
4832         if (id >= send_bitset.size()) {
4833                 send_bitset.resize (id+16, false);
4834         }
4835         if (send_bitset[id]) {
4836                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4837         }
4838         send_bitset[id] = true;
4839 }
4840
4841 void
4842 Session::mark_aux_send_id (uint32_t id)
4843 {
4844         if (id >= aux_send_bitset.size()) {
4845                 aux_send_bitset.resize (id+16, false);
4846         }
4847         if (aux_send_bitset[id]) {
4848                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4849         }
4850         aux_send_bitset[id] = true;
4851 }
4852
4853 void
4854 Session::mark_return_id (uint32_t id)
4855 {
4856         if (id >= return_bitset.size()) {
4857                 return_bitset.resize (id+16, false);
4858         }
4859         if (return_bitset[id]) {
4860                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4861         }
4862         return_bitset[id] = true;
4863 }
4864
4865 void
4866 Session::mark_insert_id (uint32_t id)
4867 {
4868         if (id >= insert_bitset.size()) {
4869                 insert_bitset.resize (id+16, false);
4870         }
4871         if (insert_bitset[id]) {
4872                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4873         }
4874         insert_bitset[id] = true;
4875 }
4876
4877 void
4878 Session::unmark_send_id (uint32_t id)
4879 {
4880         if (id < send_bitset.size()) {
4881                 send_bitset[id] = false;
4882         }
4883 }
4884
4885 void
4886 Session::unmark_aux_send_id (uint32_t id)
4887 {
4888         if (id < aux_send_bitset.size()) {
4889                 aux_send_bitset[id] = false;
4890         }
4891 }
4892
4893 void
4894 Session::unmark_return_id (uint32_t id)
4895 {
4896         if (id < return_bitset.size()) {
4897                 return_bitset[id] = false;
4898         }
4899 }
4900
4901 void
4902 Session::unmark_insert_id (uint32_t id)
4903 {
4904         if (id < insert_bitset.size()) {
4905                 insert_bitset[id] = false;
4906         }
4907 }
4908
4909 void
4910 Session::reset_native_file_format ()
4911 {
4912         boost::shared_ptr<RouteList> rl = routes.reader ();
4913         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4914                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4915                 if (tr) {
4916                         /* don't save state as we do this, there's no point
4917                          */
4918
4919                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4920                         tr->reset_write_sources (false);
4921                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4922                 }
4923         }
4924 }
4925
4926 bool
4927 Session::route_name_unique (string n) const
4928 {
4929         boost::shared_ptr<RouteList> r = routes.reader ();
4930
4931         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4932                 if ((*i)->name() == n) {
4933                         return false;
4934                 }
4935         }
4936
4937         return true;
4938 }
4939
4940 bool
4941 Session::route_name_internal (string n) const
4942 {
4943         if (auditioner && auditioner->name() == n) {
4944                 return true;
4945         }
4946
4947         if (_click_io && _click_io->name() == n) {
4948                 return true;
4949         }
4950
4951         return false;
4952 }
4953
4954 int
4955 Session::freeze_all (InterThreadInfo& itt)
4956 {
4957         boost::shared_ptr<RouteList> r = routes.reader ();
4958
4959         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4960
4961                 boost::shared_ptr<Track> t;
4962
4963                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4964                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
4965                            of every track.
4966                         */
4967                         t->freeze_me (itt);
4968                 }
4969         }
4970
4971         return 0;
4972 }
4973
4974 boost::shared_ptr<Region>
4975 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
4976                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4977                           InterThreadInfo& itt,
4978                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4979                           bool for_export, bool for_freeze)
4980 {
4981         boost::shared_ptr<Region> result;
4982         boost::shared_ptr<Playlist> playlist;
4983         boost::shared_ptr<Source> source;
4984         ChanCount diskstream_channels (track.n_channels());
4985         framepos_t position;
4986         framecnt_t this_chunk;
4987         framepos_t to_do;
4988         framepos_t latency_skip;
4989         BufferSet buffers;
4990         framepos_t len = end - start;
4991         bool need_block_size_reset = false;
4992         ChanCount const max_proc = track.max_processor_streams ();
4993         string legal_playlist_name;
4994         string possible_path;
4995
4996         if (end <= start) {
4997                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4998                                          end, start) << endmsg;
4999                 return result;
5000         }
5001
5002         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5003                         include_endpoint, for_export, for_freeze);
5004
5005         if (diskstream_channels.n(track.data_type()) < 1) {
5006                 error << _("Cannot write a range with no data.") << endmsg;
5007                 return result;
5008         }
5009
5010         // block all process callback handling
5011
5012         block_processing ();
5013
5014         {
5015                 // synchronize with AudioEngine::process_callback()
5016                 // make sure processing is not currently running
5017                 // and processing_blocked() is honored before
5018                 // acquiring thread buffers
5019                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5020         }
5021
5022         _bounce_processing_active = true;
5023
5024         /* call tree *MUST* hold route_lock */
5025
5026         if ((playlist = track.playlist()) == 0) {
5027                 goto out;
5028         }
5029
5030         legal_playlist_name = legalize_for_path (playlist->name());
5031
5032         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5033
5034                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5035                 string path = ((track.data_type() == DataType::AUDIO)
5036                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5037                                : new_midi_source_path (legal_playlist_name));
5038
5039                 if (path.empty()) {
5040                         goto out;
5041                 }
5042
5043                 try {
5044                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5045                 }
5046
5047                 catch (failed_constructor& err) {
5048                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5049                         goto out;
5050                 }
5051
5052                 srcs.push_back (source);
5053         }
5054
5055         /* tell redirects that care that we are about to use a much larger
5056          * blocksize. this will flush all plugins too, so that they are ready
5057          * to be used for this process.
5058          */
5059
5060         need_block_size_reset = true;
5061         track.set_block_size (bounce_chunk_size);
5062         _engine.main_thread()->get_buffers ();
5063
5064         position = start;
5065         to_do = len;
5066         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5067
5068         /* create a set of reasonably-sized buffers */
5069         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5070                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5071         }
5072         buffers.set_count (max_proc);
5073
5074         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5075                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5076                 boost::shared_ptr<MidiSource> ms;
5077                 if (afs) {
5078                         afs->prepare_for_peakfile_writes ();
5079                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5080                         Source::Lock lock(ms->mutex());
5081                         ms->mark_streaming_write_started(lock);
5082                 }
5083         }
5084
5085         while (to_do && !itt.cancel) {
5086
5087                 this_chunk = min (to_do, bounce_chunk_size);
5088
5089                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5090                         goto out;
5091                 }
5092
5093                 start += this_chunk;
5094                 to_do -= this_chunk;
5095                 itt.progress = (float) (1.0 - ((double) to_do / len));
5096
5097                 if (latency_skip >= bounce_chunk_size) {
5098                         latency_skip -= bounce_chunk_size;
5099                         continue;
5100                 }
5101
5102                 const framecnt_t current_chunk = this_chunk - latency_skip;
5103
5104                 uint32_t n = 0;
5105                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5106                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5107                         boost::shared_ptr<MidiSource> ms;
5108
5109                         if (afs) {
5110                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5111                                         goto out;
5112                                 }
5113                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5114                                 Source::Lock lock(ms->mutex());
5115
5116                                 const MidiBuffer& buf = buffers.get_midi(0);
5117                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5118                                         Evoral::Event<framepos_t> ev = *i;
5119                                         ev.set_time(ev.time() - position);
5120                                         ms->append_event_frames(lock, ev, ms->timeline_position());
5121                                 }
5122                         }
5123                 }
5124                 latency_skip = 0;
5125         }
5126
5127         /* post-roll, pick up delayed processor output */
5128         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5129
5130         while (latency_skip && !itt.cancel) {
5131                 this_chunk = min (latency_skip, bounce_chunk_size);
5132                 latency_skip -= this_chunk;
5133
5134                 buffers.silence (this_chunk, 0);
5135                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5136
5137                 uint32_t n = 0;
5138                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5139                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5140
5141                         if (afs) {
5142                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5143                                         goto out;
5144                                 }
5145                         }
5146                 }
5147         }
5148
5149         if (!itt.cancel) {
5150
5151                 time_t now;
5152                 struct tm* xnow;
5153                 time (&now);
5154                 xnow = localtime (&now);
5155
5156                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5157                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5158                         boost::shared_ptr<MidiSource> ms;
5159
5160                         if (afs) {
5161                                 afs->update_header (position, *xnow, now);
5162                                 afs->flush_header ();
5163                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5164                                 Source::Lock lock(ms->mutex());
5165                                 ms->mark_streaming_write_completed(lock);
5166                         }
5167                 }
5168
5169                 /* construct a region to represent the bounced material */
5170
5171                 PropertyList plist;
5172
5173                 plist.add (Properties::start, 0);
5174                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5175                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5176
5177                 result = RegionFactory::create (srcs, plist);
5178
5179         }
5180
5181   out:
5182         if (!result) {
5183                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5184                         (*src)->mark_for_remove ();
5185                         (*src)->drop_references ();
5186                 }
5187
5188         } else {
5189                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5190                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5191
5192                         if (afs)
5193                                 afs->done_with_peakfile_writes ();
5194                 }
5195         }
5196
5197         _bounce_processing_active = false;
5198
5199         if (need_block_size_reset) {
5200                 _engine.main_thread()->drop_buffers ();
5201                 track.set_block_size (get_block_size());
5202         }
5203
5204         unblock_processing ();
5205
5206         return result;
5207 }
5208
5209 gain_t*
5210 Session::gain_automation_buffer() const
5211 {
5212         return ProcessThread::gain_automation_buffer ();
5213 }
5214
5215 gain_t*
5216 Session::trim_automation_buffer() const
5217 {
5218         return ProcessThread::trim_automation_buffer ();
5219 }
5220
5221 gain_t*
5222 Session::send_gain_automation_buffer() const
5223 {
5224         return ProcessThread::send_gain_automation_buffer ();
5225 }
5226
5227 pan_t**
5228 Session::pan_automation_buffer() const
5229 {
5230         return ProcessThread::pan_automation_buffer ();
5231 }
5232
5233 BufferSet&
5234 Session::get_silent_buffers (ChanCount count)
5235 {
5236         return ProcessThread::get_silent_buffers (count);
5237 }
5238
5239 BufferSet&
5240 Session::get_scratch_buffers (ChanCount count, bool silence)
5241 {
5242         return ProcessThread::get_scratch_buffers (count, silence);
5243 }
5244
5245 BufferSet&
5246 Session::get_route_buffers (ChanCount count, bool silence)
5247 {
5248         return ProcessThread::get_route_buffers (count, silence);
5249 }
5250
5251
5252 BufferSet&
5253 Session::get_mix_buffers (ChanCount count)
5254 {
5255         return ProcessThread::get_mix_buffers (count);
5256 }
5257
5258 uint32_t
5259 Session::ntracks () const
5260 {
5261         uint32_t n = 0;
5262         boost::shared_ptr<RouteList> r = routes.reader ();
5263
5264         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5265                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5266                         ++n;
5267                 }
5268         }
5269
5270         return n;
5271 }
5272
5273 uint32_t
5274 Session::nbusses () const
5275 {
5276         uint32_t n = 0;
5277         boost::shared_ptr<RouteList> r = routes.reader ();
5278
5279         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5280                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5281                         ++n;
5282                 }
5283         }
5284
5285         return n;
5286 }
5287
5288 void
5289 Session::add_automation_list(AutomationList *al)
5290 {
5291         automation_lists[al->id()] = al;
5292 }
5293
5294 /** @return true if there is at least one record-enabled track, otherwise false */
5295 bool
5296 Session::have_rec_enabled_track () const
5297 {
5298         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5299 }
5300
5301 bool
5302 Session::have_rec_disabled_track () const
5303 {
5304     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5305 }
5306
5307 /** Update the state of our rec-enabled tracks flag */
5308 void
5309 Session::update_route_record_state ()
5310 {
5311         boost::shared_ptr<RouteList> rl = routes.reader ();
5312         RouteList::iterator i = rl->begin();
5313         while (i != rl->end ()) {
5314
5315                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5316                 if (tr && tr->record_enabled ()) {
5317                         break;
5318                 }
5319
5320                 ++i;
5321         }
5322
5323         int const old = g_atomic_int_get (&_have_rec_enabled_track);
5324
5325         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
5326
5327         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
5328                 RecordStateChanged (); /* EMIT SIGNAL */
5329         }
5330
5331         for (i = rl->begin(); i != rl->end (); ++i) {
5332                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5333                 if (tr && !tr->record_enabled ()) {
5334                         break;
5335                 }
5336         }
5337
5338         g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
5339
5340         bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
5341
5342         if (record_status() == Recording && record_arm_state_changed ) {
5343                 RecordArmStateChanged ();
5344         }
5345
5346 }
5347
5348 void
5349 Session::listen_position_changed ()
5350 {
5351         boost::shared_ptr<RouteList> r = routes.reader ();
5352
5353         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5354                 (*i)->listen_position_changed ();
5355         }
5356 }
5357
5358 void
5359 Session::solo_control_mode_changed ()
5360 {
5361         /* cancel all solo or all listen when solo control mode changes */
5362
5363         if (soloing()) {
5364                 set_solo (get_routes(), false);
5365         } else if (listening()) {
5366                 set_listen (get_routes(), false);
5367         }
5368 }
5369
5370 /** Called when a property of one of our route groups changes */
5371 void
5372 Session::route_group_property_changed (RouteGroup* rg)
5373 {
5374         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
5375 }
5376
5377 /** Called when a route is added to one of our route groups */
5378 void
5379 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5380 {
5381         RouteAddedToRouteGroup (rg, r);
5382 }
5383
5384 /** Called when a route is removed from one of our route groups */
5385 void
5386 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5387 {
5388         update_route_record_state ();
5389         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
5390 }
5391
5392 boost::shared_ptr<RouteList>
5393 Session::get_tracks () const
5394 {
5395         boost::shared_ptr<RouteList> rl = routes.reader ();
5396         boost::shared_ptr<RouteList> tl (new RouteList);
5397
5398         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
5399                 if (boost::dynamic_pointer_cast<Track> (*r)) {
5400                         if (!(*r)->is_auditioner()) {
5401                                 tl->push_back (*r);
5402                         }
5403                 }
5404         }
5405         return tl;
5406 }
5407
5408 boost::shared_ptr<RouteList>
5409 Session::get_routes_with_regions_at (framepos_t const p) const
5410 {
5411         boost::shared_ptr<RouteList> r = routes.reader ();
5412         boost::shared_ptr<RouteList> rl (new RouteList);
5413
5414         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5415                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5416                 if (!tr) {
5417                         continue;
5418                 }
5419
5420                 boost::shared_ptr<Playlist> pl = tr->playlist ();
5421                 if (!pl) {
5422                         continue;
5423                 }
5424
5425                 if (pl->has_region_at (p)) {
5426                         rl->push_back (*i);
5427                 }
5428         }
5429
5430         return rl;
5431 }
5432
5433 void
5434 Session::goto_end ()
5435 {
5436         if (_session_range_location) {
5437                 request_locate (_session_range_location->end(), false);
5438         } else {
5439                 request_locate (0, false);
5440         }
5441 }
5442
5443 void
5444 Session::goto_start ()
5445 {
5446         if (_session_range_location) {
5447                 request_locate (_session_range_location->start(), false);
5448         } else {
5449                 request_locate (0, false);
5450         }
5451 }
5452
5453 framepos_t
5454 Session::current_start_frame () const
5455 {
5456         return _session_range_location ? _session_range_location->start() : 0;
5457 }
5458
5459 framepos_t
5460 Session::current_end_frame () const
5461 {
5462         return _session_range_location ? _session_range_location->end() : 0;
5463 }
5464
5465 void
5466 Session::add_session_range_location (framepos_t start, framepos_t end)
5467 {
5468         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
5469         _locations->add (_session_range_location);
5470 }
5471
5472 void
5473 Session::step_edit_status_change (bool yn)
5474 {
5475         bool send = false;
5476
5477         bool val = false;
5478         if (yn) {
5479                 send = (_step_editors == 0);
5480                 val = true;
5481
5482                 _step_editors++;
5483         } else {
5484                 send = (_step_editors == 1);
5485                 val = false;
5486
5487                 if (_step_editors > 0) {
5488                         _step_editors--;
5489                 }
5490         }
5491
5492         if (send) {
5493                 StepEditStatusChange (val);
5494         }
5495 }
5496
5497
5498 void
5499 Session::start_time_changed (framepos_t old)
5500 {
5501         /* Update the auto loop range to match the session range
5502            (unless the auto loop range has been changed by the user)
5503         */
5504
5505         Location* s = _locations->session_range_location ();
5506         if (s == 0) {
5507                 return;
5508         }
5509
5510         Location* l = _locations->auto_loop_location ();
5511
5512         if (l && l->start() == old) {
5513                 l->set_start (s->start(), true);
5514         }
5515 }
5516
5517 void
5518 Session::end_time_changed (framepos_t old)
5519 {
5520         /* Update the auto loop range to match the session range
5521            (unless the auto loop range has been changed by the user)
5522         */
5523
5524         Location* s = _locations->session_range_location ();
5525         if (s == 0) {
5526                 return;
5527         }
5528
5529         Location* l = _locations->auto_loop_location ();
5530
5531         if (l && l->end() == old) {
5532                 l->set_end (s->end(), true);
5533         }
5534 }
5535
5536 std::vector<std::string>
5537 Session::source_search_path (DataType type) const
5538 {
5539         Searchpath sp;
5540
5541         if (session_dirs.size() == 1) {
5542                 switch (type) {
5543                 case DataType::AUDIO:
5544                         sp.push_back (_session_dir->sound_path());
5545                         break;
5546                 case DataType::MIDI:
5547                         sp.push_back (_session_dir->midi_path());
5548                         break;
5549                 }
5550         } else {
5551                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5552                         SessionDirectory sdir (i->path);
5553                         switch (type) {
5554                         case DataType::AUDIO:
5555                                 sp.push_back (sdir.sound_path());
5556                                 break;
5557                         case DataType::MIDI:
5558                                 sp.push_back (sdir.midi_path());
5559                                 break;
5560                         }
5561                 }
5562         }
5563
5564         if (type == DataType::AUDIO) {
5565                 const string sound_path_2X = _session_dir->sound_path_2X();
5566                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
5567                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
5568                                 sp.push_back (sound_path_2X);
5569                         }
5570                 }
5571         }
5572
5573         // now check the explicit (possibly user-specified) search path
5574
5575         switch (type) {
5576         case DataType::AUDIO:
5577                 sp += Searchpath(config.get_audio_search_path ());
5578                 break;
5579         case DataType::MIDI:
5580                 sp += Searchpath(config.get_midi_search_path ());
5581                 break;
5582         }
5583
5584         return sp;
5585 }
5586
5587 void
5588 Session::ensure_search_path_includes (const string& path, DataType type)
5589 {
5590         Searchpath sp;
5591
5592         if (path == ".") {
5593                 return;
5594         }
5595
5596         switch (type) {
5597         case DataType::AUDIO:
5598                 sp += Searchpath(config.get_audio_search_path ());
5599                 break;
5600         case DataType::MIDI:
5601                 sp += Searchpath (config.get_midi_search_path ());
5602                 break;
5603         }
5604
5605         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5606                 /* No need to add this new directory if it has the same inode as
5607                    an existing one; checking inode rather than name prevents duplicated
5608                    directories when we are using symlinks.
5609
5610                    On Windows, I think we could just do if (*i == path) here.
5611                 */
5612                 if (PBD::equivalent_paths (*i, path)) {
5613                         return;
5614                 }
5615         }
5616
5617         sp += path;
5618
5619         switch (type) {
5620         case DataType::AUDIO:
5621                 config.set_audio_search_path (sp.to_string());
5622                 break;
5623         case DataType::MIDI:
5624                 config.set_midi_search_path (sp.to_string());
5625                 break;
5626         }
5627 }
5628
5629 void
5630 Session::remove_dir_from_search_path (const string& dir, DataType type)
5631 {
5632         Searchpath sp;
5633
5634         switch (type) {
5635         case DataType::AUDIO:
5636                 sp = Searchpath(config.get_audio_search_path ());
5637                 break;
5638         case DataType::MIDI:
5639                 sp = Searchpath (config.get_midi_search_path ());
5640                 break;
5641         }
5642
5643         sp -= dir;
5644
5645         switch (type) {
5646         case DataType::AUDIO:
5647                 config.set_audio_search_path (sp.to_string());
5648                 break;
5649         case DataType::MIDI:
5650                 config.set_midi_search_path (sp.to_string());
5651                 break;
5652         }
5653
5654 }
5655
5656 boost::shared_ptr<Speakers>
5657 Session::get_speakers()
5658 {
5659         return _speakers;
5660 }
5661
5662 list<string>
5663 Session::unknown_processors () const
5664 {
5665         list<string> p;
5666
5667         boost::shared_ptr<RouteList> r = routes.reader ();
5668         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5669                 list<string> t = (*i)->unknown_processors ();
5670                 copy (t.begin(), t.end(), back_inserter (p));
5671         }
5672
5673         p.sort ();
5674         p.unique ();
5675
5676         return p;
5677 }
5678
5679 void
5680 Session::update_latency (bool playback)
5681 {
5682         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
5683
5684         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
5685                 return;
5686         }
5687
5688         boost::shared_ptr<RouteList> r = routes.reader ();
5689         framecnt_t max_latency = 0;
5690
5691         if (playback) {
5692                 /* reverse the list so that we work backwards from the last route to run to the first */
5693                 RouteList* rl = routes.reader().get();
5694                 r.reset (new RouteList (*rl));
5695                 reverse (r->begin(), r->end());
5696         }
5697
5698         /* compute actual latency values for the given direction and store them all in per-port
5699            structures. this will also publish the same values (to JACK) so that computation of latency
5700            for routes can consistently use public latency values.
5701         */
5702
5703         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5704                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
5705         }
5706
5707         /* because we latency compensate playback, our published playback latencies should
5708            be the same for all output ports - all material played back by ardour has
5709            the same latency, whether its caused by plugins or by latency compensation. since
5710            these may differ from the values computed above, reset all playback port latencies
5711            to the same value.
5712         */
5713
5714         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
5715
5716         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5717                 (*i)->set_public_port_latencies (max_latency, playback);
5718         }
5719
5720         if (playback) {
5721
5722                 post_playback_latency ();
5723
5724         } else {
5725
5726                 post_capture_latency ();
5727         }
5728
5729         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
5730 }
5731
5732 void
5733 Session::post_playback_latency ()
5734 {
5735         set_worst_playback_latency ();
5736
5737         boost::shared_ptr<RouteList> r = routes.reader ();
5738
5739         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5740                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5741                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
5742                 }
5743         }
5744
5745         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5746                 (*i)->set_latency_compensation (_worst_track_latency);
5747         }
5748 }
5749
5750 void
5751 Session::post_capture_latency ()
5752 {
5753         set_worst_capture_latency ();
5754
5755         /* reflect any changes in capture latencies into capture offsets
5756          */
5757
5758         boost::shared_ptr<RouteList> rl = routes.reader();
5759         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5760                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5761                 if (tr) {
5762                         tr->set_capture_offset ();
5763                 }
5764         }
5765 }
5766
5767 void
5768 Session::initialize_latencies ()
5769 {
5770         {
5771                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5772                 update_latency (false);
5773                 update_latency (true);
5774         }
5775
5776         set_worst_io_latencies ();
5777 }
5778
5779 void
5780 Session::set_worst_io_latencies ()
5781 {
5782         set_worst_playback_latency ();
5783         set_worst_capture_latency ();
5784 }
5785
5786 void
5787 Session::set_worst_playback_latency ()
5788 {
5789         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5790                 return;
5791         }
5792
5793         _worst_output_latency = 0;
5794
5795         if (!_engine.connected()) {
5796                 return;
5797         }
5798
5799         boost::shared_ptr<RouteList> r = routes.reader ();
5800
5801         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5802                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5803         }
5804
5805         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5806 }
5807
5808 void
5809 Session::set_worst_capture_latency ()
5810 {
5811         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5812                 return;
5813         }
5814
5815         _worst_input_latency = 0;
5816
5817         if (!_engine.connected()) {
5818                 return;
5819         }
5820
5821         boost::shared_ptr<RouteList> r = routes.reader ();
5822
5823         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5824                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
5825         }
5826
5827         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
5828 }
5829
5830 void
5831 Session::update_latency_compensation (bool force_whole_graph)
5832 {
5833         bool some_track_latency_changed = false;
5834
5835         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5836                 return;
5837         }
5838
5839         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
5840
5841         _worst_track_latency = 0;
5842
5843         boost::shared_ptr<RouteList> r = routes.reader ();
5844
5845         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5846                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5847                         framecnt_t tl;
5848                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
5849                                 some_track_latency_changed = true;
5850                         }
5851                         _worst_track_latency = max (tl, _worst_track_latency);
5852                 }
5853         }
5854
5855         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
5856                                                      (some_track_latency_changed ? "yes" : "no")));
5857
5858         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
5859
5860         if (some_track_latency_changed || force_whole_graph)  {
5861                 _engine.update_latencies ();
5862         }
5863
5864
5865         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5866                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5867                 if (!tr) {
5868                         continue;
5869                 }
5870                 tr->set_capture_offset ();
5871         }
5872 }
5873
5874 char
5875 Session::session_name_is_legal (const string& path)
5876 {
5877         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
5878
5879         for (int i = 0; illegal_chars[i]; ++i) {
5880                 if (path.find (illegal_chars[i]) != string::npos) {
5881                         return illegal_chars[i];
5882                 }
5883         }
5884
5885         return 0;
5886 }
5887
5888 uint32_t
5889 Session::next_control_id () const
5890 {
5891         int subtract = 0;
5892
5893         /* the monitor bus remote ID is in a different
5894          * "namespace" than regular routes. its existence doesn't
5895          * affect normal (low) numbered routes.
5896          */
5897
5898         if (_monitor_out) {
5899                 subtract++;
5900         }
5901
5902         return nroutes() - subtract;
5903 }
5904
5905 void
5906 Session::notify_remote_id_change ()
5907 {
5908         if (deletion_in_progress()) {
5909                 return;
5910         }
5911
5912         switch (Config->get_remote_model()) {
5913         case MixerOrdered:
5914                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
5915                 break;
5916         default:
5917                 break;
5918         }
5919
5920 #ifdef USE_TRACKS_CODE_FEATURES
5921                 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
5922                  * if track order has been changed by user
5923                  */
5924                 reconnect_existing_routes(true, true);
5925 #endif
5926
5927 }
5928
5929 void
5930 Session::sync_order_keys ()
5931 {
5932         if (deletion_in_progress()) {
5933                 return;
5934         }
5935
5936         /* tell everyone that something has happened to the sort keys
5937            and let them sync up with the change(s)
5938            this will give objects that manage the sort order keys the
5939            opportunity to keep them in sync if they wish to.
5940         */
5941
5942         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
5943
5944         reassign_track_numbers();
5945
5946         Route::SyncOrderKeys (); /* EMIT SIGNAL */
5947
5948         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
5949 }
5950
5951 bool
5952 Session::operation_in_progress (GQuark op) const
5953 {
5954         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
5955 }
5956
5957 boost::shared_ptr<Port>
5958 Session::ltc_input_port () const
5959 {
5960         return _ltc_input->nth (0);
5961 }
5962
5963 boost::shared_ptr<Port>
5964 Session::ltc_output_port () const
5965 {
5966         return _ltc_output->nth (0);
5967 }
5968
5969 void
5970 Session::reconnect_ltc_input ()
5971 {
5972         if (_ltc_input) {
5973
5974                 string src = Config->get_ltc_source_port();
5975
5976                 _ltc_input->disconnect (this);
5977
5978                 if (src != _("None") && !src.empty())  {
5979                         _ltc_input->nth (0)->connect (src);
5980                 }
5981         }
5982 }
5983
5984 void
5985 Session::reconnect_ltc_output ()
5986 {
5987         if (_ltc_output) {
5988
5989 #if 0
5990                 string src = Config->get_ltc_sink_port();
5991
5992                 _ltc_output->disconnect (this);
5993
5994                 if (src != _("None") && !src.empty())  {
5995                         _ltc_output->nth (0)->connect (src);
5996                 }
5997 #endif
5998         }
5999 }