libs/ardour/session.cc

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