libs/ardour/session.cc

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