libs/ardour/session.cc

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