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