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