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
2196                 catch (failed_constructor &err) {
2197                         error << _("Session: could not create new midi track.") << endmsg;
2198                         goto failed;
2199                 }
2200
2201                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2202
2203                         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;
2204                         goto failed;
2205                 }
2206
2207                 --how_many;
2208         }
2209
2210   failed:
2211         if (!new_routes.empty()) {
2212                 StateProtector sp (this);
2213                 if (Profile->get_trx()) {
2214                         add_routes (new_routes, false, false, false);
2215                 } else {
2216                         add_routes (new_routes, true, true, false);
2217                 }
2218
2219                 if (instrument) {
2220                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2221                                 PluginPtr plugin = instrument->load (*this);
2222                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2223                                 (*r)->add_processor (p, PreFader);
2224
2225                         }
2226                 }
2227         }
2228
2229         return ret;
2230 }
2231
2232 void
2233 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2234 {
2235         boost::shared_ptr<Route> midi_track (wmt.lock());
2236
2237         if (!midi_track) {
2238                 return;
2239         }
2240
2241         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2242
2243                 if (change.after.n_audio() <= change.before.n_audio()) {
2244                         return;
2245                 }
2246
2247                 /* new audio ports: make sure the audio goes somewhere useful,
2248                    unless the user has no-auto-connect selected.
2249
2250                    The existing ChanCounts don't matter for this call as they are only
2251                    to do with matching input and output indices, and we are only changing
2252                    outputs here.
2253                 */
2254
2255                 ChanCount dummy;
2256
2257                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
2258         }
2259 }
2260
2261 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
2262  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
2263  *  @param output_start As \a input_start, but for outputs.
2264  */
2265 void
2266 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
2267                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
2268 {
2269         if (!IO::connecting_legal) {
2270                 return;
2271         }
2272
2273         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2274
2275         if (with_lock) {
2276                 lm.acquire ();
2277         }
2278
2279         /* If both inputs and outputs are auto-connected to physical ports,
2280            use the max of input and output offsets to ensure auto-connected
2281            port numbers always match up (e.g. the first audio input and the
2282            first audio output of the route will have the same physical
2283            port number).  Otherwise just use the lowest input or output
2284            offset possible.
2285         */
2286
2287         DEBUG_TRACE (DEBUG::Graph,
2288                      string_compose("Auto-connect: existing in = %1 out = %2\n",
2289                                     existing_inputs, existing_outputs));
2290
2291         const bool in_out_physical =
2292                 (Config->get_input_auto_connect() & AutoConnectPhysical)
2293                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
2294                 && connect_inputs;
2295
2296         const ChanCount in_offset = in_out_physical
2297                 ? ChanCount::max(existing_inputs, existing_outputs)
2298                 : existing_inputs;
2299
2300         const ChanCount out_offset = in_out_physical
2301                 ? ChanCount::max(existing_inputs, existing_outputs)
2302                 : existing_outputs;
2303
2304         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2305                 vector<string> physinputs;
2306                 vector<string> physoutputs;
2307
2308                 _engine.get_physical_outputs (*t, physoutputs);
2309                 _engine.get_physical_inputs (*t, physinputs);
2310
2311                 if (!physinputs.empty() && connect_inputs) {
2312                         uint32_t nphysical_in = physinputs.size();
2313
2314                         DEBUG_TRACE (DEBUG::Graph,
2315                                      string_compose("There are %1 physical inputs of type %2\n",
2316                                                     nphysical_in, *t));
2317
2318                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
2319                                 string port;
2320
2321                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
2322                                         DEBUG_TRACE (DEBUG::Graph,
2323                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
2324                                                                     in_offset.get(*t), i, nphysical_in,
2325                                                                     (in_offset.get(*t) + i) % nphysical_in));
2326                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
2327                                 }
2328
2329                                 DEBUG_TRACE (DEBUG::Graph,
2330                                              string_compose("Connect route %1 IN to %2\n",
2331                                                             route->name(), port));
2332
2333                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
2334                                         break;
2335                                 }
2336
2337                                 ChanCount one_added (*t, 1);
2338                                 existing_inputs += one_added;
2339                         }
2340                 }
2341
2342                 if (!physoutputs.empty()) {
2343                         uint32_t nphysical_out = physoutputs.size();
2344                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
2345                                 string port;
2346
2347                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
2348                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
2349                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
2350                                         /* master bus is audio only */
2351                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
2352                                                 port = _master_out->input()->ports().port(*t,
2353                                                                 i % _master_out->input()->n_ports().get(*t))->name();
2354                                         }
2355                                 }
2356
2357                                 DEBUG_TRACE (DEBUG::Graph,
2358                                              string_compose("Connect route %1 OUT to %2\n",
2359                                                             route->name(), port));
2360
2361                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2362                                         break;
2363                                 }
2364
2365                                 ChanCount one_added (*t, 1);
2366                                 existing_outputs += one_added;
2367                         }
2368                 }
2369         }
2370 }
2371
2372 void
2373 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2374 {
2375         /* TRX does stuff here, ardour does not (but probably should). This is called after an engine reset (in particular).
2376          */
2377 }
2378
2379 #ifdef USE_TRACKS_CODE_FEATURES
2380
2381 void
2382 Session::reconnect_midi_scene_ports(bool inputs)
2383 {
2384         if (inputs) {
2385                 scene_in()->disconnect_all ();
2386
2387                 std::vector<EngineStateController::MidiPortState> midi_port_states;
2388                 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2389
2390                 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2391
2392                 for (; state_iter != midi_port_states.end(); ++state_iter) {
2393                         if (state_iter->active && state_iter->available && state_iter->connected) {
2394                                 scene_in()->connect (state_iter->name);
2395                         }
2396                 }
2397
2398         } else {
2399                 scene_out()->disconnect_all ();
2400
2401                 std::vector<EngineStateController::MidiPortState> midi_port_states;
2402                 EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2403
2404                 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2405
2406                 for (; state_iter != midi_port_states.end(); ++state_iter) {
2407                         if (state_iter->active && state_iter->available && state_iter->connected) {
2408                                 scene_out()->connect (state_iter->name);
2409                         }
2410                 }
2411
2412         }
2413 }
2414
2415 #endif
2416
2417 /** Caller must not hold process lock
2418  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2419  */
2420 list< boost::shared_ptr<AudioTrack> >
2421 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2422                           uint32_t how_many, string name_template)
2423 {
2424         char track_name[32];
2425         uint32_t track_id = 0;
2426         string port;
2427         RouteList new_routes;
2428         list<boost::shared_ptr<AudioTrack> > ret;
2429
2430         string name_pattern;
2431
2432         if (Profile->get_trx() ) {
2433                 name_pattern = "Track ";
2434         } else {
2435                 name_pattern = "Audio ";
2436         }
2437
2438         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _(name_pattern.c_str() );
2439
2440         while (how_many) {
2441
2442                 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2443                         error << "cannot find name for new audio track" << endmsg;
2444                         goto failed;
2445                 }
2446
2447                 boost::shared_ptr<AudioTrack> track;
2448
2449                 try {
2450                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2451
2452                         if (track->init ()) {
2453                                 goto failed;
2454                         }
2455
2456                         track->use_new_diskstream();
2457
2458 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2459                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2460 #endif
2461                         {
2462                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2463
2464                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2465                                         error << string_compose (
2466                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2467                                                 input_channels, output_channels)
2468                                               << endmsg;
2469                                         goto failed;
2470                                 }
2471
2472                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2473                                         error << string_compose (
2474                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2475                                                 input_channels, output_channels)
2476                                               << endmsg;
2477                                         goto failed;
2478                                 }
2479                         }
2480
2481                         if (route_group) {
2482                                 route_group->add (track);
2483                         }
2484
2485                         track->non_realtime_input_change();
2486
2487                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2488                         if (Config->get_remote_model() == UserOrdered) {
2489                                 track->set_remote_control_id (next_control_id());
2490                         }
2491
2492                         new_routes.push_back (track);
2493                         ret.push_back (track);
2494                 }
2495
2496                 catch (failed_constructor &err) {
2497                         error << _("Session: could not create new audio track.") << endmsg;
2498                         goto failed;
2499                 }
2500
2501                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2502
2503                         error << pfe.what() << endmsg;
2504                         goto failed;
2505                 }
2506
2507                 --how_many;
2508         }
2509
2510   failed:
2511         if (!new_routes.empty()) {
2512                 StateProtector sp (this);
2513                 if (Profile->get_trx()) {
2514                         add_routes (new_routes, false, false, false);
2515                 } else {
2516                         add_routes (new_routes, true, true, false);
2517                 }
2518         }
2519
2520         return ret;
2521 }
2522
2523 /** Caller must not hold process lock.
2524  *  @param name_template string to use for the start of the name, or "" to use "Bus".
2525  */
2526 RouteList
2527 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2528 {
2529         char bus_name[32];
2530         uint32_t bus_id = 0;
2531         string port;
2532         RouteList ret;
2533
2534         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2535
2536         while (how_many) {
2537                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2538                         error << "cannot find name for new audio bus" << endmsg;
2539                         goto failure;
2540                 }
2541
2542                 try {
2543                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2544
2545                         if (bus->init ()) {
2546                                 goto failure;
2547                         }
2548
2549 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2550                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2551 #endif
2552                         {
2553                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2554
2555                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2556                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2557                                                                  input_channels, output_channels)
2558                                               << endmsg;
2559                                         goto failure;
2560                                 }
2561
2562
2563                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2564                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2565                                                                  input_channels, output_channels)
2566                                               << endmsg;
2567                                         goto failure;
2568                                 }
2569                         }
2570
2571                         if (route_group) {
2572                                 route_group->add (bus);
2573                         }
2574                         if (Config->get_remote_model() == UserOrdered) {
2575                                 bus->set_remote_control_id (next_control_id());
2576                         }
2577
2578                         bus->add_internal_return ();
2579
2580                         ret.push_back (bus);
2581
2582                         ARDOUR::GUIIdle ();
2583                 }
2584
2585
2586                 catch (failed_constructor &err) {
2587                         error << _("Session: could not create new audio route.") << endmsg;
2588                         goto failure;
2589                 }
2590
2591                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2592                         error << pfe.what() << endmsg;
2593                         goto failure;
2594                 }
2595
2596
2597                 --how_many;
2598         }
2599
2600   failure:
2601         if (!ret.empty()) {
2602                 StateProtector sp (this);
2603                 if (Profile->get_trx()) {
2604                         add_routes (ret, false, false, false);
2605                 } else {
2606                         add_routes (ret, false, true, true); // autoconnect // outputs only
2607                 }
2608         }
2609
2610         return ret;
2611
2612 }
2613
2614 RouteList
2615 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2616 {
2617         RouteList ret;
2618         uint32_t control_id;
2619         XMLTree tree;
2620         uint32_t number = 0;
2621         const uint32_t being_added = how_many;
2622
2623         if (!tree.read (template_path.c_str())) {
2624                 return ret;
2625         }
2626
2627         XMLNode* node = tree.root();
2628
2629         IO::disable_connecting ();
2630
2631         control_id = next_control_id ();
2632
2633         while (how_many) {
2634
2635                 XMLNode node_copy (*node);
2636
2637                 /* Remove IDs of everything so that new ones are used */
2638                 node_copy.remove_property_recursively (X_("id"));
2639
2640                 try {
2641                         char name[32];
2642
2643                         if (!name_base.empty()) {
2644
2645                                 /* if we're adding more than one routes, force
2646                                  * all the names of the new routes to be
2647                                  * numbered, via the final parameter.
2648                                  */
2649
2650                                 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2651                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2652                                         /*NOTREACHDE*/
2653                                 }
2654
2655                         } else {
2656
2657                                 string const route_name  = node_copy.property(X_("name"))->value ();
2658
2659                                 /* generate a new name by adding a number to the end of the template name */
2660                                 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2661                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2662                                         abort(); /*NOTREACHED*/
2663                                 }
2664                         }
2665
2666                         /* set this name in the XML description that we are about to use */
2667                         Route::set_name_in_state (node_copy, name);
2668
2669                         /* trim bitslots from listen sends so that new ones are used */
2670                         XMLNodeList children = node_copy.children ();
2671                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2672                                 if ((*i)->name() == X_("Processor")) {
2673                                         XMLProperty* role = (*i)->property (X_("role"));
2674                                         if (role && role->value() == X_("Listen")) {
2675                                                 (*i)->remove_property (X_("bitslot"));
2676                                         }
2677                                 }
2678                         }
2679
2680                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2681
2682                         if (route == 0) {
2683                                 error << _("Session: cannot create track/bus from template description") << endmsg;
2684                                 goto out;
2685                         }
2686
2687                         if (boost::dynamic_pointer_cast<Track>(route)) {
2688                                 /* force input/output change signals so that the new diskstream
2689                                    picks up the configuration of the route. During session
2690                                    loading this normally happens in a different way.
2691                                 */
2692
2693                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2694
2695                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2696                                 change.after = route->input()->n_ports();
2697                                 route->input()->changed (change, this);
2698                                 change.after = route->output()->n_ports();
2699                                 route->output()->changed (change, this);
2700                         }
2701
2702                         route->set_remote_control_id (control_id);
2703                         ++control_id;
2704
2705                         ret.push_back (route);
2706                 }
2707
2708                 catch (failed_constructor &err) {
2709                         error << _("Session: could not create new route from template") << endmsg;
2710                         goto out;
2711                 }
2712
2713                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2714                         error << pfe.what() << endmsg;
2715                         goto out;
2716                 }
2717
2718                 --how_many;
2719         }
2720
2721   out:
2722         if (!ret.empty()) {
2723                 StateProtector sp (this);
2724                 if (Profile->get_trx()) {
2725                         add_routes (ret, false, false, false);
2726                 } else {
2727                         add_routes (ret, true, true, false);
2728                 }
2729                 IO::enable_connecting ();
2730         }
2731
2732         return ret;
2733 }
2734
2735 void
2736 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2737 {
2738         try {
2739                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2740                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2741
2742         } catch (...) {
2743                 error << _("Adding new tracks/busses failed") << endmsg;
2744         }
2745
2746         graph_reordered ();
2747
2748         update_latency (true);
2749         update_latency (false);
2750
2751         set_dirty();
2752
2753         if (save) {
2754                 save_state (_current_snapshot_name);
2755         }
2756
2757         reassign_track_numbers();
2758
2759         update_route_record_state ();
2760
2761         RouteAdded (new_routes); /* EMIT SIGNAL */
2762 }
2763
2764 void
2765 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2766 {
2767         ChanCount existing_inputs;
2768         ChanCount existing_outputs;
2769         uint32_t order = next_control_id();
2770
2771         if (_order_hint > -1) {
2772                 order = _order_hint;
2773                 _order_hint = -1;
2774         }
2775
2776         count_existing_track_channels (existing_inputs, existing_outputs);
2777
2778         {
2779                 RCUWriter<RouteList> writer (routes);
2780                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2781                 r->insert (r->end(), new_routes.begin(), new_routes.end());
2782
2783                 /* if there is no control out and we're not in the middle of loading,
2784                    resort the graph here. if there is a control out, we will resort
2785                    toward the end of this method. if we are in the middle of loading,
2786                    we will resort when done.
2787                 */
2788
2789                 if (!_monitor_out && IO::connecting_legal) {
2790                         resort_routes_using (r);
2791                 }
2792         }
2793
2794         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2795
2796                 boost::weak_ptr<Route> wpr (*x);
2797                 boost::shared_ptr<Route> r (*x);
2798
2799                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2800                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2801                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2802                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2803                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2804                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2805
2806                 if (r->is_master()) {
2807                         _master_out = r;
2808                 }
2809
2810                 if (r->is_monitor()) {
2811                         _monitor_out = r;
2812                 }
2813
2814                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2815                 if (tr) {
2816                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2817                         track_playlist_changed (boost::weak_ptr<Track> (tr));
2818                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
2819
2820                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2821                         if (mt) {
2822                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2823                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2824                         }
2825                 }
2826
2827
2828                 if (input_auto_connect || output_auto_connect) {
2829                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2830                 }
2831
2832                 /* order keys are a GUI responsibility but we need to set up
2833                    reasonable defaults because they also affect the remote control
2834                    ID in most situations.
2835                 */
2836
2837                 if (!r->has_order_key ()) {
2838                         if (r->is_auditioner()) {
2839                                 /* use an arbitrarily high value */
2840                                 r->set_order_key (UINT_MAX);
2841                         } else {
2842                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2843                                 r->set_order_key (order);
2844                                 order++;
2845                         }
2846                 }
2847
2848                 ARDOUR::GUIIdle ();
2849         }
2850
2851         if (_monitor_out && IO::connecting_legal) {
2852                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2853
2854                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2855                         if ((*x)->is_monitor()) {
2856                                 /* relax */
2857                         } else if ((*x)->is_master()) {
2858                                         /* relax */
2859                         } else {
2860                                 (*x)->enable_monitor_send ();
2861                         }
2862                 }
2863         }
2864 }
2865
2866 void
2867 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2868 {
2869         boost::shared_ptr<RouteList> r = routes.reader ();
2870         boost::shared_ptr<Send> s;
2871
2872         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2873                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2874                         s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO);
2875                 }
2876         }
2877 }
2878
2879 void
2880 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2881 {
2882         boost::shared_ptr<RouteList> r = routes.reader ();
2883         boost::shared_ptr<Send> s;
2884
2885         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2886                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2887                         s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY);
2888                 }
2889         }
2890 }
2891
2892 void
2893 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2894 {
2895         boost::shared_ptr<RouteList> r = routes.reader ();
2896         boost::shared_ptr<Send> s;
2897
2898         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2899                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2900                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2901                 }
2902         }
2903 }
2904
2905 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2906 void
2907 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2908 {
2909         boost::shared_ptr<RouteList> r = routes.reader ();
2910         boost::shared_ptr<RouteList> t (new RouteList);
2911
2912         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2913                 /* no MIDI sends because there are no MIDI busses yet */
2914                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2915                         t->push_back (*i);
2916                 }
2917         }
2918
2919         add_internal_sends (dest, p, t);
2920 }
2921
2922 void
2923 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2924 {
2925         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2926                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2927         }
2928 }
2929
2930 void
2931 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2932 {
2933         add_internal_send (dest, sender->before_processor_for_index (index), sender);
2934 }
2935
2936 void
2937 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2938 {
2939         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2940                 return;
2941         }
2942
2943         if (!dest->internal_return()) {
2944                 dest->add_internal_return ();
2945         }
2946
2947         sender->add_aux_send (dest, before);
2948
2949         graph_reordered ();
2950 }
2951
2952
2953 void
2954 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
2955 {
2956         { // RCU Writer scope
2957                 RCUWriter<RouteList> writer (routes);
2958                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2959
2960
2961                 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
2962
2963                         if (*iter == _master_out) {
2964                                 continue;
2965                         }
2966
2967                         (*iter)->set_solo (false, this);
2968
2969                         rs->remove (*iter);
2970
2971                         /* deleting the master out seems like a dumb
2972                            idea, but its more of a UI policy issue
2973                            than our concern.
2974                         */
2975
2976                         if (*iter == _master_out) {
2977                                 _master_out = boost::shared_ptr<Route> ();
2978                         }
2979
2980                         if (*iter == _monitor_out) {
2981                                 _monitor_out.reset ();
2982                         }
2983
2984                         update_route_solo_state ();
2985
2986                         // We need to disconnect the route's inputs and outputs
2987
2988                         (*iter)->input()->disconnect (0);
2989                         (*iter)->output()->disconnect (0);
2990
2991                         /* if the route had internal sends sending to it, remove them */
2992                         if ((*iter)->internal_return()) {
2993
2994                                 boost::shared_ptr<RouteList> r = routes.reader ();
2995                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2996                                         boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
2997                                         if (s) {
2998                                                 (*i)->remove_processor (s);
2999                                         }
3000                                 }
3001                         }
3002
3003                         /* if the monitoring section had a pointer to this route, remove it */
3004                         if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3005                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3006                                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3007                                 (*iter)->remove_aux_or_listen (_monitor_out);
3008                         }
3009
3010                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3011                         if (mt && mt->step_editing()) {
3012                                 if (_step_editors > 0) {
3013                                         _step_editors--;
3014                                 }
3015                         }
3016
3017                         RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3018                 }
3019
3020                 /* writer goes out of scope, forces route list update */
3021
3022         } // end of RCU Writer scope
3023
3024         update_latency_compensation ();
3025         set_dirty();
3026
3027         /* Re-sort routes to remove the graph's current references to the one that is
3028          * going away, then flush old references out of the graph.
3029          * Wave Tracks: reconnect routes
3030          */
3031
3032         if (ARDOUR::Profile->get_trx () ) {
3033                 reconnect_existing_routes(true, false);
3034         } else {
3035                 resort_routes ();
3036         }
3037
3038         if (_process_graph) {
3039                 _process_graph->clear_other_chain ();
3040         }
3041
3042         /* get rid of it from the dead wood collection in the route list manager */
3043         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3044
3045         routes.flush ();
3046
3047         /* try to cause everyone to drop their references
3048          * and unregister ports from the backend
3049          */
3050         PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3051
3052         for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3053                 (*iter)->drop_references ();
3054         }
3055
3056         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3057
3058         /* save the new state of the world */
3059
3060         if (save_state (_current_snapshot_name)) {
3061                 save_history (_current_snapshot_name);
3062         }
3063
3064         reassign_track_numbers();
3065         update_route_record_state ();
3066 }
3067
3068 void
3069 Session::remove_route (boost::shared_ptr<Route> route)
3070 {
3071         boost::shared_ptr<RouteList> rl (new RouteList);
3072         rl->push_back (route);
3073         remove_routes (rl);
3074 }
3075
3076 void
3077 Session::route_mute_changed (void* /*src*/)
3078 {
3079         set_dirty ();
3080 }
3081
3082 void
3083 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3084 {
3085         boost::shared_ptr<Route> route = wpr.lock();
3086         if (!route) {
3087                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3088                 return;
3089         }
3090
3091         if (route->listening_via_monitor ()) {
3092
3093                 if (Config->get_exclusive_solo()) {
3094                         /* new listen: disable all other listen */
3095                         boost::shared_ptr<RouteList> r = routes.reader ();
3096                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3097                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3098                                         continue;
3099                                 }
3100                                 (*i)->set_listen (false, this);
3101                         }
3102                 }
3103
3104                 _listen_cnt++;
3105
3106         } else if (_listen_cnt > 0) {
3107
3108                 _listen_cnt--;
3109         }
3110
3111         update_route_solo_state ();
3112 }
3113 void
3114 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3115 {
3116         boost::shared_ptr<Route> route = wpr.lock ();
3117
3118         if (!route) {
3119                 /* should not happen */
3120                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3121                 return;
3122         }
3123
3124         bool send_changed = false;
3125
3126         if (route->solo_isolated()) {
3127                 if (_solo_isolated_cnt == 0) {
3128                         send_changed = true;
3129                 }
3130                 _solo_isolated_cnt++;
3131         } else if (_solo_isolated_cnt > 0) {
3132                 _solo_isolated_cnt--;
3133                 if (_solo_isolated_cnt == 0) {
3134                         send_changed = true;
3135                 }
3136         }
3137
3138         if (send_changed) {
3139                 IsolatedChanged (); /* EMIT SIGNAL */
3140         }
3141 }
3142
3143 void
3144 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
3145 {
3146         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3147
3148         if (!self_solo_change) {
3149                 // session doesn't care about changes to soloed-by-others
3150                 return;
3151         }
3152
3153         if (solo_update_disabled) {
3154                 // We know already
3155                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
3156                 return;
3157         }
3158
3159         boost::shared_ptr<Route> route = wpr.lock ();
3160         assert (route);
3161
3162         boost::shared_ptr<RouteList> r = routes.reader ();
3163         int32_t delta;
3164
3165         if (route->self_soloed()) {
3166                 delta = 1;
3167         } else {
3168                 delta = -1;
3169         }
3170
3171         RouteGroup* rg = route->route_group ();
3172         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
3173
3174         if (delta == 1 && Config->get_exclusive_solo()) {
3175
3176                 /* new solo: disable all other solos, but not the group if its solo-enabled */
3177
3178                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3179                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3180                             (leave_group_alone && ((*i)->route_group() == rg))) {
3181                                 continue;
3182                         }
3183                         (*i)->set_solo (false, this);
3184                 }
3185         }
3186
3187         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3188
3189         solo_update_disabled = true;
3190
3191         RouteList uninvolved;
3192
3193         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3194
3195         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3196                 bool via_sends_only;
3197                 bool in_signal_flow;
3198
3199                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3200                     (leave_group_alone && ((*i)->route_group() == rg))) {
3201                         continue;
3202                 }
3203
3204                 in_signal_flow = false;
3205
3206                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3207
3208                 if ((*i)->feeds (route, &via_sends_only)) {
3209                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3210                         if (!via_sends_only) {
3211                                 if (!route->soloed_by_others_upstream()) {
3212                                         (*i)->mod_solo_by_others_downstream (delta);
3213                                 }
3214                         } else {
3215                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3216                         }
3217                         in_signal_flow = true;
3218                 } else {
3219                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3220                 }
3221
3222                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3223
3224                 if (route->feeds (*i, &via_sends_only)) {
3225                         /* propagate solo upstream only if routing other than
3226                            sends is involved, but do consider the other route
3227                            (*i) to be part of the signal flow even if only
3228                            sends are involved.
3229                         */
3230                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3231                                                                   route->name(),
3232                                                                   (*i)->name(),
3233                                                                   via_sends_only,
3234                                                                   route->soloed_by_others_downstream(),
3235                                                                   route->soloed_by_others_upstream()));
3236                         if (!via_sends_only) {
3237                                 if (!route->soloed_by_others_downstream()) {
3238                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3239                                         (*i)->mod_solo_by_others_upstream (delta);
3240                                 } else {
3241                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
3242                                 }
3243                         } else {
3244                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3245                         }
3246                         in_signal_flow = true;
3247                 } else {
3248                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3249                 }
3250
3251                 if (!in_signal_flow) {
3252                         uninvolved.push_back (*i);
3253                 }
3254         }
3255
3256         solo_update_disabled = false;
3257         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3258
3259         update_route_solo_state (r);
3260
3261         /* now notify that the mute state of the routes not involved in the signal
3262            pathway of the just-solo-changed route may have altered.
3263         */
3264
3265         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3266                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3267                 (*i)->act_on_mute ();
3268                 (*i)->mute_changed (this);
3269         }
3270
3271         SoloChanged (); /* EMIT SIGNAL */
3272         set_dirty();
3273 }
3274
3275 void
3276 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3277 {
3278         /* now figure out if anything that matters is soloed (or is "listening")*/
3279
3280         bool something_soloed = false;
3281         uint32_t listeners = 0;
3282         uint32_t isolated = 0;
3283
3284         if (!r) {
3285                 r = routes.reader();
3286         }
3287
3288         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3289                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3290                         something_soloed = true;
3291                 }
3292
3293                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3294                         if (Config->get_solo_control_is_listen_control()) {
3295                                 listeners++;
3296                         } else {
3297                                 (*i)->set_listen (false, this);
3298                         }
3299                 }
3300
3301                 if ((*i)->solo_isolated()) {
3302                         isolated++;
3303                 }
3304         }
3305
3306         if (something_soloed != _non_soloed_outs_muted) {
3307                 _non_soloed_outs_muted = something_soloed;
3308                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3309         }
3310
3311         _listen_cnt = listeners;
3312
3313         if (isolated != _solo_isolated_cnt) {
3314                 _solo_isolated_cnt = isolated;
3315                 IsolatedChanged (); /* EMIT SIGNAL */
3316         }
3317
3318         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3319                                                   something_soloed, listeners, isolated));
3320 }
3321
3322 boost::shared_ptr<RouteList>
3323 Session::get_routes_with_internal_returns() const
3324 {
3325         boost::shared_ptr<RouteList> r = routes.reader ();
3326         boost::shared_ptr<RouteList> rl (new RouteList);
3327
3328         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3329                 if ((*i)->internal_return ()) {
3330                         rl->push_back (*i);
3331                 }
3332         }
3333         return rl;
3334 }
3335
3336 bool
3337 Session::io_name_is_legal (const std::string& name)
3338 {
3339         boost::shared_ptr<RouteList> r = routes.reader ();
3340
3341         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3342                 if ((*i)->name() == name) {
3343                         return false;
3344                 }
3345
3346                 if ((*i)->has_io_processor_named (name)) {
3347                         return false;
3348                 }
3349         }
3350
3351         return true;
3352 }
3353
3354 void
3355 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
3356 {
3357         RouteList rl2;
3358         vector<string> connections;
3359
3360         /* if we are passed only a single route and we're not told to turn
3361          * others off, then just do the simple thing.
3362          */
3363
3364         if (flip_others == false && rl->size() == 1) {
3365                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
3366                 if (mt) {
3367                         mt->set_input_active (onoff);
3368                         return;
3369                 }
3370         }
3371
3372         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
3373
3374                 PortSet& ps ((*rt)->input()->ports());
3375
3376                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
3377                         p->get_connections (connections);
3378                 }
3379
3380                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
3381                         routes_using_input_from (*s, rl2);
3382                 }
3383
3384                 /* scan all relevant routes to see if others are on or off */
3385
3386                 bool others_are_already_on = false;
3387
3388                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3389
3390                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3391
3392                         if (!mt) {
3393                                 continue;
3394                         }
3395
3396                         if ((*r) != (*rt)) {
3397                                 if (mt->input_active()) {
3398                                         others_are_already_on = true;
3399                                 }
3400                         } else {
3401                                 /* this one needs changing */
3402                                 mt->set_input_active (onoff);
3403                         }
3404                 }
3405
3406                 if (flip_others) {
3407
3408                         /* globally reverse other routes */
3409
3410                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3411                                 if ((*r) != (*rt)) {
3412                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3413                                         if (mt) {
3414                                                 mt->set_input_active (!others_are_already_on);
3415                                         }
3416                                 }
3417                         }
3418                 }
3419         }
3420 }
3421
3422 void
3423 Session::routes_using_input_from (const string& str, RouteList& rl)
3424 {
3425         boost::shared_ptr<RouteList> r = routes.reader();
3426
3427         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3428                 if ((*i)->input()->connected_to (str)) {
3429                         rl.push_back (*i);
3430                 }
3431         }
3432 }
3433
3434 boost::shared_ptr<Route>
3435 Session::route_by_name (string name)
3436 {
3437         boost::shared_ptr<RouteList> r = routes.reader ();
3438
3439         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3440                 if ((*i)->name() == name) {
3441                         return *i;
3442                 }
3443         }
3444
3445         return boost::shared_ptr<Route> ((Route*) 0);
3446 }
3447
3448 boost::shared_ptr<Route>
3449 Session::route_by_id (PBD::ID id)
3450 {
3451         boost::shared_ptr<RouteList> r = routes.reader ();
3452
3453         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3454                 if ((*i)->id() == id) {
3455                         return *i;
3456                 }
3457         }
3458
3459         return boost::shared_ptr<Route> ((Route*) 0);
3460 }
3461
3462 boost::shared_ptr<Track>
3463 Session::track_by_diskstream_id (PBD::ID id)
3464 {
3465         boost::shared_ptr<RouteList> r = routes.reader ();
3466
3467         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3468                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3469                 if (t && t->using_diskstream_id (id)) {
3470                         return t;
3471                 }
3472         }
3473
3474         return boost::shared_ptr<Track> ();
3475 }
3476
3477 boost::shared_ptr<Route>
3478 Session::route_by_remote_id (uint32_t id)
3479 {
3480         boost::shared_ptr<RouteList> r = routes.reader ();
3481
3482         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3483                 if ((*i)->remote_control_id() == id) {
3484                         return *i;
3485                 }
3486         }
3487
3488         return boost::shared_ptr<Route> ((Route*) 0);
3489 }
3490
3491
3492 void
3493 Session::reassign_track_numbers ()
3494 {
3495         int64_t tn = 0;
3496         int64_t bn = 0;
3497         RouteList r (*(routes.reader ()));
3498         SignalOrderRouteSorter sorter;
3499         r.sort (sorter);
3500
3501         StateProtector sp (this);
3502
3503         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3504                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3505                         (*i)->set_track_number(++tn);
3506                 }
3507                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
3508                         (*i)->set_track_number(--bn);
3509                 }
3510         }
3511         const uint32_t decimals = ceilf (log10f (tn + 1));
3512         const bool decimals_changed = _track_number_decimals != decimals;
3513         _track_number_decimals = decimals;
3514
3515         if (decimals_changed && config.get_track_name_number ()) {
3516                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3517                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3518                         if (t) {
3519                                 t->resync_track_name();
3520                         }
3521                 }
3522                 // trigger GUI re-layout
3523                 config.ParameterChanged("track-name-number");
3524         }
3525 }
3526
3527 void
3528 Session::playlist_region_added (boost::weak_ptr<Region> w)
3529 {
3530         boost::shared_ptr<Region> r = w.lock ();
3531         if (!r) {
3532                 return;
3533         }
3534
3535         /* These are the operations that are currently in progress... */
3536         list<GQuark> curr = _current_trans_quarks;
3537         curr.sort ();
3538
3539         /* ...and these are the operations during which we want to update
3540            the session range location markers.
3541         */
3542         list<GQuark> ops;
3543         ops.push_back (Operations::capture);
3544         ops.push_back (Operations::paste);
3545         ops.push_back (Operations::duplicate_region);
3546         ops.push_back (Operations::insert_file);
3547         ops.push_back (Operations::insert_region);
3548         ops.push_back (Operations::drag_region_brush);
3549         ops.push_back (Operations::region_drag);
3550         ops.push_back (Operations::selection_grab);
3551         ops.push_back (Operations::region_fill);
3552         ops.push_back (Operations::fill_selection);
3553         ops.push_back (Operations::create_region);
3554         ops.push_back (Operations::region_copy);
3555         ops.push_back (Operations::fixed_time_region_copy);
3556         ops.sort ();
3557
3558         /* See if any of the current operations match the ones that we want */
3559         list<GQuark> in;
3560         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3561
3562         /* If so, update the session range markers */
3563         if (!in.empty ()) {
3564                 maybe_update_session_range (r->position (), r->last_frame ());
3565         }
3566 }
3567
3568 /** Update the session range markers if a is before the current start or
3569  *  b is after the current end.
3570  */
3571 void
3572 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3573 {
3574         if (_state_of_the_state & Loading) {
3575                 return;
3576         }
3577
3578         if (_session_range_location == 0) {
3579
3580                 add_session_range_location (a, b);
3581
3582         } else {
3583
3584                 if (a < _session_range_location->start()) {
3585                         _session_range_location->set_start (a);
3586                 }
3587
3588                 if (b > _session_range_location->end()) {
3589                         _session_range_location->set_end (b);
3590                 }
3591         }
3592 }
3593
3594 void
3595 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3596 {
3597         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3598                 maybe_update_session_range (i->to, i->to + i->length);
3599         }
3600 }
3601
3602 void
3603 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3604 {
3605         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3606                 maybe_update_session_range (i->from, i->to);
3607         }
3608 }
3609
3610 /* Region management */
3611
3612 boost::shared_ptr<Region>
3613 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3614 {
3615         const RegionFactory::RegionMap& regions (RegionFactory::regions());
3616         RegionFactory::RegionMap::const_iterator i;
3617         boost::shared_ptr<Region> region;
3618
3619         Glib::Threads::Mutex::Lock lm (region_lock);
3620
3621         for (i = regions.begin(); i != regions.end(); ++i) {
3622
3623                 region = i->second;
3624
3625                 if (region->whole_file()) {
3626
3627                         if (child->source_equivalent (region)) {
3628                                 return region;
3629                         }
3630                 }
3631         }
3632
3633         return boost::shared_ptr<Region> ();
3634 }
3635
3636 int
3637 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3638 {
3639         set<boost::shared_ptr<Region> > relevant_regions;
3640
3641         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3642                 RegionFactory::get_regions_using_source (*s, relevant_regions);
3643         }
3644
3645         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3646                 set<boost::shared_ptr<Region> >::iterator tmp;
3647
3648                 tmp = r;
3649                 ++tmp;
3650
3651                 playlists->destroy_region (*r);
3652                 RegionFactory::map_remove (*r);
3653
3654                 (*r)->drop_sources ();
3655                 (*r)->drop_references ();
3656
3657                 relevant_regions.erase (r);
3658
3659                 r = tmp;
3660         }
3661
3662         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3663
3664                 {
3665                         Glib::Threads::Mutex::Lock ls (source_lock);
3666                         /* remove from the main source list */
3667                         sources.erase ((*s)->id());
3668                 }
3669
3670                 (*s)->mark_for_remove ();
3671                 (*s)->drop_references ();
3672
3673                 s = srcs.erase (s);
3674         }
3675
3676         return 0;
3677 }
3678
3679 int
3680 Session::remove_last_capture ()
3681 {
3682         list<boost::shared_ptr<Source> > srcs;
3683
3684         boost::shared_ptr<RouteList> rl = routes.reader ();
3685         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3686                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3687                 if (!tr) {
3688                         continue;
3689                 }
3690
3691                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3692
3693                 if (!l.empty()) {
3694                         srcs.insert (srcs.end(), l.begin(), l.end());
3695                         l.clear ();
3696                 }
3697         }
3698
3699         destroy_sources (srcs);
3700
3701         save_state (_current_snapshot_name);
3702
3703         return 0;
3704 }
3705
3706 /* Source Management */
3707
3708 void
3709 Session::add_source (boost::shared_ptr<Source> source)
3710 {
3711         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3712         pair<SourceMap::iterator,bool> result;
3713
3714         entry.first = source->id();
3715         entry.second = source;
3716
3717         {
3718                 Glib::Threads::Mutex::Lock lm (source_lock);
3719                 result = sources.insert (entry);
3720         }
3721
3722         if (result.second) {
3723
3724                 /* yay, new source */
3725
3726                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3727
3728                 if (fs) {
3729                         if (!fs->within_session()) {
3730                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3731                         }
3732                 }
3733
3734                 set_dirty();
3735
3736                 boost::shared_ptr<AudioFileSource> afs;
3737
3738                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3739                         if (Config->get_auto_analyse_audio()) {
3740                                 Analyser::queue_source_for_analysis (source, false);
3741                         }
3742                 }
3743
3744                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3745         }
3746 }
3747
3748 void
3749 Session::remove_source (boost::weak_ptr<Source> src)
3750 {
3751         if (_state_of_the_state & Deletion) {
3752                 return;
3753         }
3754
3755         SourceMap::iterator i;
3756         boost::shared_ptr<Source> source = src.lock();
3757
3758         if (!source) {
3759                 return;
3760         }
3761
3762         {
3763                 Glib::Threads::Mutex::Lock lm (source_lock);
3764
3765                 if ((i = sources.find (source->id())) != sources.end()) {
3766                         sources.erase (i);
3767                 }
3768         }
3769
3770         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
3771
3772                 /* save state so we don't end up with a session file
3773                    referring to non-existent sources.
3774                 */
3775
3776                 save_state (_current_snapshot_name);
3777         }
3778 }
3779
3780 boost::shared_ptr<Source>
3781 Session::source_by_id (const PBD::ID& id)
3782 {
3783         Glib::Threads::Mutex::Lock lm (source_lock);
3784         SourceMap::iterator i;
3785         boost::shared_ptr<Source> source;
3786
3787         if ((i = sources.find (id)) != sources.end()) {
3788                 source = i->second;
3789         }
3790
3791         return source;
3792 }
3793
3794 boost::shared_ptr<AudioFileSource>
3795 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
3796 {
3797         /* Restricted to audio files because only audio sources have channel
3798            as a property.
3799         */
3800
3801         Glib::Threads::Mutex::Lock lm (source_lock);
3802
3803         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
3804                 boost::shared_ptr<AudioFileSource> afs
3805                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3806
3807                 if (afs && afs->path() == path && chn == afs->channel()) {
3808                         return afs;
3809                 }
3810         }
3811
3812         return boost::shared_ptr<AudioFileSource>();
3813 }
3814
3815 boost::shared_ptr<MidiSource>
3816 Session::midi_source_by_path (const std::string& path) const
3817 {
3818         /* Restricted to MIDI files because audio sources require a channel
3819            for unique identification, in addition to a path.
3820         */
3821
3822         Glib::Threads::Mutex::Lock lm (source_lock);
3823
3824         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
3825                 boost::shared_ptr<MidiSource> ms
3826                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
3827                 boost::shared_ptr<FileSource> fs
3828                         = boost::dynamic_pointer_cast<FileSource>(s->second);
3829
3830                 if (ms && fs && fs->path() == path) {
3831                         return ms;
3832                 }
3833         }
3834
3835         return boost::shared_ptr<MidiSource>();
3836 }
3837
3838 uint32_t
3839 Session::count_sources_by_origin (const string& path)
3840 {
3841         uint32_t cnt = 0;
3842         Glib::Threads::Mutex::Lock lm (source_lock);
3843
3844         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3845                 boost::shared_ptr<FileSource> fs
3846                         = boost::dynamic_pointer_cast<FileSource>(i->second);
3847
3848                 if (fs && fs->origin() == path) {
3849                         ++cnt;
3850                 }
3851         }
3852
3853         return cnt;
3854 }
3855
3856 string
3857 Session::peak_path (string base) const
3858 {
3859         if (Glib::path_is_absolute (base)) {
3860
3861                 /* rip the session dir from the audiofile source */
3862
3863                 string session_path;
3864                 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
3865                 bool in_another_session = true;
3866
3867                 if (base.find (interchange_dir_string) != string::npos) {
3868
3869                         session_path = Glib::path_get_dirname (base); /* now ends in audiofiles */
3870                         session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
3871                         session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
3872                         session_path = Glib::path_get_dirname (session_path); /* now has session path */
3873
3874                         /* see if it is within our session */
3875
3876                         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3877                                 if (i->path == session_path) {
3878                                         in_another_session = false;
3879                                         break;
3880                                 }
3881                         }
3882                 } else {
3883                         in_another_session = false;
3884                 }
3885
3886
3887                 if (in_another_session) {
3888                         SessionDirectory sd (session_path);
3889                         return Glib::build_filename (sd.peak_path(), Glib::path_get_basename (base) + peakfile_suffix);
3890                 }
3891         }
3892
3893         base = Glib::path_get_basename (base);
3894         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3895 }
3896
3897 string
3898 Session::new_audio_source_path_for_embedded (const std::string& path)
3899 {
3900         /* embedded source:
3901          *
3902          * we know that the filename is already unique because it exists
3903          * out in the filesystem.
3904          *
3905          * However, when we bring it into the session, we could get a
3906          * collision.
3907          *
3908          * Eg. two embedded files:
3909          *
3910          *          /foo/bar/baz.wav
3911          *          /frob/nic/baz.wav
3912          *
3913          * When merged into session, these collide.
3914          *
3915          * There will not be a conflict with in-memory sources
3916          * because when the source was created we already picked
3917          * a unique name for it.
3918          *
3919          * This collision is not likely to be common, but we have to guard
3920          * against it.  So, if there is a collision, take the md5 hash of the
3921          * the path, and use that as the filename instead.
3922          */
3923
3924         SessionDirectory sdir (get_best_session_directory_for_new_audio());
3925         string base = Glib::path_get_basename (path);
3926         string newpath = Glib::build_filename (sdir.sound_path(), base);
3927
3928         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
3929
3930                 MD5 md5;
3931
3932                 md5.digestString (path.c_str());
3933                 md5.writeToString ();
3934                 base = md5.digestChars;
3935
3936                 string ext = get_suffix (path);
3937
3938                 if (!ext.empty()) {
3939                         base += '.';
3940                         base += ext;
3941                 }
3942
3943                 newpath = Glib::build_filename (sdir.sound_path(), base);
3944
3945                 /* if this collides, we're screwed */
3946
3947                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
3948                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
3949                         return string();
3950                 }
3951
3952         }
3953
3954         return newpath;
3955 }
3956
3957 /** Return true if there are no audio file sources that use @param name as
3958  * the filename component of their path.
3959  *
3960  * Return false otherwise.
3961  *
3962  * This method MUST ONLY be used to check in-session, mono files since it
3963  * hard-codes the channel of the audio file source we are looking for as zero.
3964  *
3965  * If/when Ardour supports native files in non-mono formats, the logic here
3966  * will need to be revisited.
3967  */
3968 bool
3969 Session::audio_source_name_is_unique (const string& name)
3970 {
3971         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
3972         vector<space_and_path>::iterator i;
3973         uint32_t existing = 0;
3974
3975         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
3976
3977                 /* note that we search *without* the extension so that
3978                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3979                    in the event that this new name is required for
3980                    a file format change.
3981                 */
3982
3983                 const string spath = *i;
3984
3985                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
3986                         existing++;
3987                         break;
3988                 }
3989
3990                 /* it is possible that we have the path already
3991                  * assigned to a source that has not yet been written
3992                  * (ie. the write source for a diskstream). we have to
3993                  * check this in order to make sure that our candidate
3994                  * path isn't used again, because that can lead to
3995                  * two Sources point to the same file with different
3996                  * notions of their removability.
3997                  */
3998
3999
4000                 string possible_path = Glib::build_filename (spath, name);
4001
4002                 if (audio_source_by_path_and_channel (possible_path, 0)) {
4003                         existing++;
4004                         break;
4005                 }
4006         }
4007
4008         return (existing == 0);
4009 }
4010
4011 string
4012 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)
4013 {
4014         ostringstream sstr;
4015         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4016
4017         if (destructive) {
4018                 sstr << 'T';
4019                 sstr << setfill ('0') << setw (4) << cnt;
4020                 sstr << legalized_base;
4021         } else {
4022                 sstr << legalized_base;
4023
4024                 if (take_required || related_exists) {
4025                         sstr << '-';
4026                         sstr << cnt;
4027                 }
4028         }
4029
4030         if (nchan == 2) {
4031                 if (chan == 0) {
4032                         sstr << "%L";
4033                 } else {
4034                         sstr << "%R";
4035                 }
4036         } else if (nchan > 2) {
4037                 if (nchan < 26) {
4038                         sstr << '%';
4039                         sstr << 'a' + chan;
4040                 } else {
4041                         /* XXX what? more than 26 channels! */
4042                         sstr << '%';
4043                         sstr << chan+1;
4044                 }
4045         }
4046
4047         sstr << ext;
4048
4049         return sstr.str();
4050 }
4051
4052 /** Return a unique name based on \a base for a new internal audio source */
4053 string
4054 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4055 {
4056         uint32_t cnt;
4057         string possible_name;
4058         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4059         string legalized;
4060         bool some_related_source_name_exists = false;
4061
4062         legalized = legalize_for_path (base);
4063
4064         // Find a "version" of the base name that doesn't exist in any of the possible directories.
4065
4066         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4067
4068                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4069
4070                 if (audio_source_name_is_unique (possible_name)) {
4071                         break;
4072                 }
4073
4074                 some_related_source_name_exists = true;
4075
4076                 if (cnt > limit) {
4077                         error << string_compose(
4078                                         _("There are already %1 recordings for %2, which I consider too many."),
4079                                         limit, base) << endmsg;
4080                         destroy ();
4081                         throw failed_constructor();
4082                 }
4083         }
4084
4085         /* We've established that the new name does not exist in any session
4086          * directory, so now find out which one we should use for this new
4087          * audio source.
4088          */
4089
4090         SessionDirectory sdir (get_best_session_directory_for_new_audio());
4091
4092         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4093
4094         return s;
4095 }
4096
4097 /** Return a unique name based on `base` for a new internal MIDI source */
4098 string
4099 Session::new_midi_source_path (const string& base)
4100 {
4101         uint32_t cnt;
4102         char buf[PATH_MAX+1];
4103         const uint32_t limit = 10000;
4104         string legalized;
4105         string possible_path;
4106         string possible_name;
4107
4108         buf[0] = '\0';
4109         legalized = legalize_for_path (base);
4110
4111         // Find a "version" of the file name that doesn't exist in any of the possible directories.
4112         std::vector<string> sdirs = source_search_path(DataType::MIDI);
4113
4114         /* - the main session folder is the first in the vector.
4115          * - after checking all locations for file-name uniqueness,
4116          *   we keep the one from the last iteration as new file name
4117          * - midi files are small and should just be kept in the main session-folder
4118          *
4119          * -> reverse the array, check main session folder last and use that as location
4120          *    for MIDI files.
4121          */
4122         std::reverse(sdirs.begin(), sdirs.end());
4123
4124         for (cnt = 1; cnt <= limit; ++cnt) {
4125
4126                 vector<space_and_path>::iterator i;
4127                 uint32_t existing = 0;
4128
4129                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4130
4131                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4132                         possible_name = buf;
4133
4134                         possible_path = Glib::build_filename (*i, possible_name);
4135
4136                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4137                                 existing++;
4138                         }
4139
4140                         if (midi_source_by_path (possible_path)) {
4141                                 existing++;
4142                         }
4143                 }
4144
4145                 if (existing == 0) {
4146                         break;
4147                 }
4148
4149                 if (cnt > limit) {
4150                         error << string_compose(
4151                                         _("There are already %1 recordings for %2, which I consider too many."),
4152                                         limit, base) << endmsg;
4153                         destroy ();
4154                         return 0;
4155                 }
4156         }
4157
4158         /* No need to "find best location" for software/app-based RAID, because
4159            MIDI is so small that we always put it in the same place.
4160         */
4161
4162         return possible_path;
4163 }
4164
4165
4166 /** Create a new within-session audio source */
4167 boost::shared_ptr<AudioFileSource>
4168 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4169 {
4170         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4171
4172         if (!path.empty()) {
4173                 return boost::dynamic_pointer_cast<AudioFileSource> (
4174                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
4175         } else {
4176                 throw failed_constructor ();
4177         }
4178 }
4179
4180 /** Create a new within-session MIDI source */
4181 boost::shared_ptr<MidiSource>
4182 Session::create_midi_source_for_session (string const & basic_name)
4183 {
4184         const string path = new_midi_source_path (basic_name);
4185
4186         if (!path.empty()) {
4187                 return boost::dynamic_pointer_cast<SMFSource> (
4188                         SourceFactory::createWritable (
4189                                 DataType::MIDI, *this, path, false, frame_rate()));
4190         } else {
4191                 throw failed_constructor ();
4192         }
4193 }
4194
4195 /** Create a new within-session MIDI source */
4196 boost::shared_ptr<MidiSource>
4197 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4198 {
4199         /* the caller passes in the track the source will be used in,
4200            so that we can keep the numbering sane.
4201
4202            Rationale: a track with the name "Foo" that has had N
4203            captures carried out so far will ALREADY have a write source
4204            named "Foo-N+1.mid" waiting to be used for the next capture.
4205
4206            If we call new_midi_source_name() we will get "Foo-N+2". But
4207            there is no region corresponding to "Foo-N+1", so when
4208            "Foo-N+2" appears in the track, the gap presents the user
4209            with odd behaviour - why did it skip past Foo-N+1?
4210
4211            We could explain this to the user in some odd way, but
4212            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4213            use "Foo-N+1" here.
4214
4215            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4216         */
4217
4218         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4219         assert (mt);
4220         std::string name = track->steal_write_source_name ();
4221
4222         if (name.empty()) {
4223                 return boost::shared_ptr<MidiSource>();
4224         }
4225
4226         /* MIDI files are small, just put them in the first location of the
4227            session source search path.
4228         */
4229
4230         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4231
4232         return boost::dynamic_pointer_cast<SMFSource> (
4233                 SourceFactory::createWritable (
4234                         DataType::MIDI, *this, path, false, frame_rate()));
4235 }
4236
4237
4238 void
4239 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4240 {
4241         if (playlist->hidden()) {
4242                 return;
4243         }
4244
4245         playlists->add (playlist);
4246
4247         if (unused) {
4248                 playlist->release();
4249         }
4250
4251         set_dirty();
4252 }
4253
4254 void
4255 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4256 {
4257         if (_state_of_the_state & Deletion) {
4258                 return;
4259         }
4260
4261         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4262
4263         if (!playlist) {
4264                 return;
4265         }
4266
4267         playlists->remove (playlist);
4268
4269         set_dirty();
4270 }
4271
4272 void
4273 Session::set_audition (boost::shared_ptr<Region> r)
4274 {
4275         pending_audition_region = r;
4276         add_post_transport_work (PostTransportAudition);
4277         _butler->schedule_transport_work ();
4278 }
4279
4280 void
4281 Session::audition_playlist ()
4282 {
4283         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4284         ev->region.reset ();
4285         queue_event (ev);
4286 }
4287
4288 void
4289 Session::non_realtime_set_audition ()
4290 {
4291         assert (pending_audition_region);
4292         auditioner->audition_region (pending_audition_region);
4293         pending_audition_region.reset ();
4294         AuditionActive (true); /* EMIT SIGNAL */
4295 }
4296
4297 void
4298 Session::audition_region (boost::shared_ptr<Region> r)
4299 {
4300         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4301         ev->region = r;
4302         queue_event (ev);
4303 }
4304
4305 void
4306 Session::cancel_audition ()
4307 {
4308         if (!auditioner) {
4309                 return;
4310         }
4311         if (auditioner->auditioning()) {
4312                 auditioner->cancel_audition ();
4313                 AuditionActive (false); /* EMIT SIGNAL */
4314         }
4315 }
4316
4317 bool
4318 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4319 {
4320         if (a->is_monitor()) {
4321                 return true;
4322         }
4323         if (b->is_monitor()) {
4324                 return false;
4325         }
4326         return a->order_key () < b->order_key ();
4327 }
4328
4329 bool
4330 Session::is_auditioning () const
4331 {
4332         /* can be called before we have an auditioner object */
4333         if (auditioner) {
4334                 return auditioner->auditioning();
4335         } else {
4336                 return false;
4337         }
4338 }
4339
4340 void
4341 Session::graph_reordered ()
4342 {
4343         /* don't do this stuff if we are setting up connections
4344            from a set_state() call or creating new tracks. Ditto for deletion.
4345         */
4346
4347         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4348                 return;
4349         }
4350
4351         /* every track/bus asked for this to be handled but it was deferred because
4352            we were connecting. do it now.
4353         */
4354
4355         request_input_change_handling ();
4356
4357         resort_routes ();
4358
4359         /* force all diskstreams to update their capture offset values to
4360            reflect any changes in latencies within the graph.
4361         */
4362
4363         boost::shared_ptr<RouteList> rl = routes.reader ();
4364         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4365                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4366                 if (tr) {
4367                         tr->set_capture_offset ();
4368                 }
4369         }
4370 }
4371
4372 /** @return Number of frames that there is disk space available to write,
4373  *  if known.
4374  */
4375 boost::optional<framecnt_t>
4376 Session::available_capture_duration ()
4377 {
4378         Glib::Threads::Mutex::Lock lm (space_lock);
4379
4380         if (_total_free_4k_blocks_uncertain) {
4381                 return boost::optional<framecnt_t> ();
4382         }
4383
4384         float sample_bytes_on_disk = 4.0; // keep gcc happy
4385
4386         switch (config.get_native_file_data_format()) {
4387         case FormatFloat:
4388                 sample_bytes_on_disk = 4.0;
4389                 break;
4390
4391         case FormatInt24:
4392                 sample_bytes_on_disk = 3.0;
4393                 break;
4394
4395         case FormatInt16:
4396                 sample_bytes_on_disk = 2.0;
4397                 break;
4398
4399         default:
4400                 /* impossible, but keep some gcc versions happy */
4401                 fatal << string_compose (_("programming error: %1"),
4402                                          X_("illegal native file data format"))
4403                       << endmsg;
4404                 abort(); /*NOTREACHED*/
4405         }
4406
4407         double scale = 4096.0 / sample_bytes_on_disk;
4408
4409         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4410                 return max_framecnt;
4411         }
4412
4413         return (framecnt_t) floor (_total_free_4k_blocks * scale);
4414 }
4415
4416 void
4417 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
4418 {
4419         {
4420                 RCUWriter<BundleList> writer (_bundles);
4421                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4422                 b->push_back (bundle);
4423         }
4424
4425         if (emit_signal) {
4426                 BundleAddedOrRemoved (); /* EMIT SIGNAL */
4427         }
4428
4429         set_dirty();
4430 }
4431
4432 void
4433 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
4434 {
4435         bool removed = false;
4436
4437         {
4438                 RCUWriter<BundleList> writer (_bundles);
4439                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4440                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
4441
4442                 if (i != b->end()) {
4443                         b->erase (i);
4444                         removed = true;
4445                 }
4446         }
4447
4448         if (removed) {
4449                  BundleAddedOrRemoved (); /* EMIT SIGNAL */
4450         }
4451
4452         set_dirty();
4453 }
4454
4455 boost::shared_ptr<Bundle>
4456 Session::bundle_by_name (string name) const
4457 {
4458         boost::shared_ptr<BundleList> b = _bundles.reader ();
4459
4460         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
4461                 if ((*i)->name() == name) {
4462                         return* i;
4463                 }
4464         }
4465
4466         return boost::shared_ptr<Bundle> ();
4467 }
4468
4469 void
4470 Session::tempo_map_changed (const PropertyChange&)
4471 {
4472         clear_clicks ();
4473
4474         playlists->update_after_tempo_map_change ();
4475
4476         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4477
4478         set_dirty ();
4479 }
4480
4481 void
4482 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
4483 {
4484         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
4485                 (*i)->recompute_frames_from_bbt ();
4486         }
4487 }
4488
4489 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4490  * the given count with the current block size.
4491  */
4492 void
4493 Session::ensure_buffers (ChanCount howmany)
4494 {
4495         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4496 }
4497
4498 void
4499 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4500 {
4501         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4502                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4503         }
4504 }
4505
4506 uint32_t
4507 Session::next_insert_id ()
4508 {
4509         /* this doesn't really loop forever. just think about it */
4510
4511         while (true) {
4512                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4513                         if (!insert_bitset[n]) {
4514                                 insert_bitset[n] = true;
4515                                 return n;
4516
4517                         }
4518                 }
4519
4520                 /* none available, so resize and try again */
4521
4522                 insert_bitset.resize (insert_bitset.size() + 16, false);
4523         }
4524 }
4525
4526 uint32_t
4527 Session::next_send_id ()
4528 {
4529         /* this doesn't really loop forever. just think about it */
4530
4531         while (true) {
4532                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4533                         if (!send_bitset[n]) {
4534                                 send_bitset[n] = true;
4535                                 return n;
4536
4537                         }
4538                 }
4539
4540                 /* none available, so resize and try again */
4541
4542                 send_bitset.resize (send_bitset.size() + 16, false);
4543         }
4544 }
4545
4546 uint32_t
4547 Session::next_aux_send_id ()
4548 {
4549         /* this doesn't really loop forever. just think about it */
4550
4551         while (true) {
4552                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4553                         if (!aux_send_bitset[n]) {
4554                                 aux_send_bitset[n] = true;
4555                                 return n;
4556
4557                         }
4558                 }
4559
4560                 /* none available, so resize and try again */
4561
4562                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4563         }
4564 }
4565
4566 uint32_t
4567 Session::next_return_id ()
4568 {
4569         /* this doesn't really loop forever. just think about it */
4570
4571         while (true) {
4572                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
4573                         if (!return_bitset[n]) {
4574                                 return_bitset[n] = true;
4575                                 return n;
4576
4577                         }
4578                 }
4579
4580                 /* none available, so resize and try again */
4581
4582                 return_bitset.resize (return_bitset.size() + 16, false);
4583         }
4584 }
4585
4586 void
4587 Session::mark_send_id (uint32_t id)
4588 {
4589         if (id >= send_bitset.size()) {
4590                 send_bitset.resize (id+16, false);
4591         }
4592         if (send_bitset[id]) {
4593                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4594         }
4595         send_bitset[id] = true;
4596 }
4597
4598 void
4599 Session::mark_aux_send_id (uint32_t id)
4600 {
4601         if (id >= aux_send_bitset.size()) {
4602                 aux_send_bitset.resize (id+16, false);
4603         }
4604         if (aux_send_bitset[id]) {
4605                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4606         }
4607         aux_send_bitset[id] = true;
4608 }
4609
4610 void
4611 Session::mark_return_id (uint32_t id)
4612 {
4613         if (id >= return_bitset.size()) {
4614                 return_bitset.resize (id+16, false);
4615         }
4616         if (return_bitset[id]) {
4617                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4618         }
4619         return_bitset[id] = true;
4620 }
4621
4622 void
4623 Session::mark_insert_id (uint32_t id)
4624 {
4625         if (id >= insert_bitset.size()) {
4626                 insert_bitset.resize (id+16, false);
4627         }
4628         if (insert_bitset[id]) {
4629                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4630         }
4631         insert_bitset[id] = true;
4632 }
4633
4634 void
4635 Session::unmark_send_id (uint32_t id)
4636 {
4637         if (id < send_bitset.size()) {
4638                 send_bitset[id] = false;
4639         }
4640 }
4641
4642 void
4643 Session::unmark_aux_send_id (uint32_t id)
4644 {
4645         if (id < aux_send_bitset.size()) {
4646                 aux_send_bitset[id] = false;
4647         }
4648 }
4649
4650 void
4651 Session::unmark_return_id (uint32_t id)
4652 {
4653         if (id < return_bitset.size()) {
4654                 return_bitset[id] = false;
4655         }
4656 }
4657
4658 void
4659 Session::unmark_insert_id (uint32_t id)
4660 {
4661         if (id < insert_bitset.size()) {
4662                 insert_bitset[id] = false;
4663         }
4664 }
4665
4666 void
4667 Session::reset_native_file_format ()
4668 {
4669         boost::shared_ptr<RouteList> rl = routes.reader ();
4670         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4671                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4672                 if (tr) {
4673                         /* don't save state as we do this, there's no point
4674                          */
4675
4676                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4677                         tr->reset_write_sources (false);
4678                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4679                 }
4680         }
4681 }
4682
4683 bool
4684 Session::route_name_unique (string n) const
4685 {
4686         boost::shared_ptr<RouteList> r = routes.reader ();
4687
4688         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4689                 if ((*i)->name() == n) {
4690                         return false;
4691                 }
4692         }
4693
4694         return true;
4695 }
4696
4697 bool
4698 Session::route_name_internal (string n) const
4699 {
4700         if (auditioner && auditioner->name() == n) {
4701                 return true;
4702         }
4703
4704         if (_click_io && _click_io->name() == n) {
4705                 return true;
4706         }
4707
4708         return false;
4709 }
4710
4711 int
4712 Session::freeze_all (InterThreadInfo& itt)
4713 {
4714         boost::shared_ptr<RouteList> r = routes.reader ();
4715
4716         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4717
4718                 boost::shared_ptr<Track> t;
4719
4720                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4721                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
4722                            of every track.
4723                         */
4724                         t->freeze_me (itt);
4725                 }
4726         }
4727
4728         return 0;
4729 }
4730
4731 boost::shared_ptr<Region>
4732 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
4733                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4734                           InterThreadInfo& itt,
4735                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4736                           bool for_export, bool for_freeze)
4737 {
4738         boost::shared_ptr<Region> result;
4739         boost::shared_ptr<Playlist> playlist;
4740         boost::shared_ptr<Source> source;
4741         ChanCount diskstream_channels (track.n_channels());
4742         framepos_t position;
4743         framecnt_t this_chunk;
4744         framepos_t to_do;
4745         framepos_t latency_skip;
4746         BufferSet buffers;
4747         framepos_t len = end - start;
4748         bool need_block_size_reset = false;
4749         ChanCount const max_proc = track.max_processor_streams ();
4750         string legal_playlist_name;
4751         string possible_path;
4752
4753         if (end <= start) {
4754                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4755                                          end, start) << endmsg;
4756                 return result;
4757         }
4758
4759         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
4760                         include_endpoint, for_export, for_freeze);
4761
4762         if (diskstream_channels.n(track.data_type()) < 1) {
4763                 error << _("Cannot write a range with no data.") << endmsg;
4764                 return result;
4765         }
4766
4767         // block all process callback handling
4768
4769         block_processing ();
4770
4771         {
4772                 // synchronize with AudioEngine::process_callback()
4773                 // make sure processing is not currently running
4774                 // and processing_blocked() is honored before
4775                 // acquiring thread buffers
4776                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4777         }
4778
4779         _bounce_processing_active = true;
4780
4781         /* call tree *MUST* hold route_lock */
4782
4783         if ((playlist = track.playlist()) == 0) {
4784                 goto out;
4785         }
4786
4787         legal_playlist_name = legalize_for_path (playlist->name());
4788
4789         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
4790
4791                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
4792                 string path = ((track.data_type() == DataType::AUDIO)
4793                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
4794                                : new_midi_source_path (legal_playlist_name));
4795
4796                 if (path.empty()) {
4797                         goto out;
4798                 }
4799
4800                 try {
4801                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
4802                 }
4803
4804                 catch (failed_constructor& err) {
4805                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
4806                         goto out;
4807                 }
4808
4809                 srcs.push_back (source);
4810         }
4811
4812         /* tell redirects that care that we are about to use a much larger
4813          * blocksize. this will flush all plugins too, so that they are ready
4814          * to be used for this process.
4815          */
4816
4817         need_block_size_reset = true;
4818         track.set_block_size (bounce_chunk_size);
4819         _engine.main_thread()->get_buffers ();
4820
4821         position = start;
4822         to_do = len;
4823         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4824
4825         /* create a set of reasonably-sized buffers */
4826         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4827                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
4828         }
4829         buffers.set_count (max_proc);
4830
4831         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4832                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4833                 boost::shared_ptr<MidiSource> ms;
4834                 if (afs) {
4835                         afs->prepare_for_peakfile_writes ();
4836                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
4837                         Source::Lock lock(ms->mutex());
4838                         ms->mark_streaming_write_started(lock);
4839                 }
4840         }
4841
4842         while (to_do && !itt.cancel) {
4843
4844                 this_chunk = min (to_do, bounce_chunk_size);
4845
4846                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
4847                         goto out;
4848                 }
4849
4850                 start += this_chunk;
4851                 to_do -= this_chunk;
4852                 itt.progress = (float) (1.0 - ((double) to_do / len));
4853
4854                 if (latency_skip >= bounce_chunk_size) {
4855                         latency_skip -= bounce_chunk_size;
4856                         continue;
4857                 }
4858
4859                 const framecnt_t current_chunk = this_chunk - latency_skip;
4860
4861                 uint32_t n = 0;
4862                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4863                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4864                         boost::shared_ptr<MidiSource> ms;
4865
4866                         if (afs) {
4867                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
4868                                         goto out;
4869                                 }
4870                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
4871                                 Source::Lock lock(ms->mutex());
4872
4873                                 const MidiBuffer& buf = buffers.get_midi(0);
4874                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
4875                                         Evoral::Event<framepos_t> ev = *i;
4876                                         ev.set_time(ev.time() - position);
4877                                         ms->append_event_frames(lock, ev, ms->timeline_position());
4878                                 }
4879                         }
4880                 }
4881                 latency_skip = 0;
4882         }
4883
4884         /* post-roll, pick up delayed processor output */
4885         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4886
4887         while (latency_skip && !itt.cancel) {
4888                 this_chunk = min (latency_skip, bounce_chunk_size);
4889                 latency_skip -= this_chunk;
4890
4891                 buffers.silence (this_chunk, 0);
4892                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
4893
4894                 uint32_t n = 0;
4895                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4896                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4897
4898                         if (afs) {
4899                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4900                                         goto out;
4901                                 }
4902                         }
4903                 }
4904         }
4905
4906         if (!itt.cancel) {
4907
4908                 time_t now;
4909                 struct tm* xnow;
4910                 time (&now);
4911                 xnow = localtime (&now);
4912
4913                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4914                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4915                         boost::shared_ptr<MidiSource> ms;
4916
4917                         if (afs) {
4918                                 afs->update_header (position, *xnow, now);
4919                                 afs->flush_header ();
4920                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
4921                                 Source::Lock lock(ms->mutex());
4922                                 ms->mark_streaming_write_completed(lock);
4923                         }
4924                 }
4925
4926                 /* construct a region to represent the bounced material */
4927
4928                 PropertyList plist;
4929
4930                 plist.add (Properties::start, 0);
4931                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4932                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4933
4934                 result = RegionFactory::create (srcs, plist);
4935
4936         }
4937
4938   out:
4939         if (!result) {
4940                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4941                         (*src)->mark_for_remove ();
4942                         (*src)->drop_references ();
4943                 }
4944
4945         } else {
4946                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4947                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4948
4949                         if (afs)
4950                                 afs->done_with_peakfile_writes ();
4951                 }
4952         }
4953
4954         _bounce_processing_active = false;
4955
4956         if (need_block_size_reset) {
4957                 _engine.main_thread()->drop_buffers ();
4958                 track.set_block_size (get_block_size());
4959         }
4960
4961         unblock_processing ();
4962
4963         return result;
4964 }
4965
4966 gain_t*
4967 Session::gain_automation_buffer() const
4968 {
4969         return ProcessThread::gain_automation_buffer ();
4970 }
4971
4972 gain_t*
4973 Session::trim_automation_buffer() const
4974 {
4975         return ProcessThread::trim_automation_buffer ();
4976 }
4977
4978 gain_t*
4979 Session::send_gain_automation_buffer() const
4980 {
4981         return ProcessThread::send_gain_automation_buffer ();
4982 }
4983
4984 pan_t**
4985 Session::pan_automation_buffer() const
4986 {
4987         return ProcessThread::pan_automation_buffer ();
4988 }
4989
4990 BufferSet&
4991 Session::get_silent_buffers (ChanCount count)
4992 {
4993         return ProcessThread::get_silent_buffers (count);
4994 }
4995
4996 BufferSet&
4997 Session::get_scratch_buffers (ChanCount count, bool silence)
4998 {
4999         return ProcessThread::get_scratch_buffers (count, silence);
5000 }
5001
5002 BufferSet&
5003 Session::get_route_buffers (ChanCount count, bool silence)
5004 {
5005         return ProcessThread::get_route_buffers (count, silence);
5006 }
5007
5008
5009 BufferSet&
5010 Session::get_mix_buffers (ChanCount count)
5011 {
5012         return ProcessThread::get_mix_buffers (count);
5013 }
5014
5015 uint32_t
5016 Session::ntracks () const
5017 {
5018         uint32_t n = 0;
5019         boost::shared_ptr<RouteList> r = routes.reader ();
5020
5021         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5022                 if (boost::dynamic_pointer_cast<Track> (*i)) {
5023                         ++n;
5024                 }
5025         }
5026
5027         return n;
5028 }
5029
5030 uint32_t
5031 Session::nbusses () const
5032 {
5033         uint32_t n = 0;
5034         boost::shared_ptr<RouteList> r = routes.reader ();
5035
5036         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5037                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5038                         ++n;
5039                 }
5040         }
5041
5042         return n;
5043 }
5044
5045 void
5046 Session::add_automation_list(AutomationList *al)
5047 {
5048         automation_lists[al->id()] = al;
5049 }
5050
5051 /** @return true if there is at least one record-enabled track, otherwise false */
5052 bool
5053 Session::have_rec_enabled_track () const
5054 {
5055         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5056 }
5057
5058 bool
5059 Session::have_rec_disabled_track () const
5060 {
5061     return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5062 }
5063
5064 /** Update the state of our rec-enabled tracks flag */
5065 void
5066 Session::update_route_record_state ()
5067 {
5068         boost::shared_ptr<RouteList> rl = routes.reader ();
5069         RouteList::iterator i = rl->begin();
5070         while (i != rl->end ()) {
5071
5072                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5073                 if (tr && tr->record_enabled ()) {
5074                         break;
5075                 }
5076
5077                 ++i;
5078         }
5079
5080         int const old = g_atomic_int_get (&_have_rec_enabled_track);
5081
5082         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
5083
5084         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
5085                 RecordStateChanged (); /* EMIT SIGNAL */
5086         }
5087
5088
5089     i = rl->begin();
5090         while (i != rl->end ()) {
5091
5092                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5093                 if (tr && !tr->record_enabled ()) {
5094                         break;
5095                 }
5096
5097                 ++i;
5098         }
5099
5100     g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
5101 }
5102
5103 void
5104 Session::listen_position_changed ()
5105 {
5106         boost::shared_ptr<RouteList> r = routes.reader ();
5107
5108         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5109                 (*i)->listen_position_changed ();
5110         }
5111 }
5112
5113 void
5114 Session::solo_control_mode_changed ()
5115 {
5116         /* cancel all solo or all listen when solo control mode changes */
5117
5118         if (soloing()) {
5119                 set_solo (get_routes(), false);
5120         } else if (listening()) {
5121                 set_listen (get_routes(), false);
5122         }
5123 }
5124
5125 /** Called when a property of one of our route groups changes */
5126 void
5127 Session::route_group_property_changed (RouteGroup* rg)
5128 {
5129         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
5130 }
5131
5132 /** Called when a route is added to one of our route groups */
5133 void
5134 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5135 {
5136         RouteAddedToRouteGroup (rg, r);
5137 }
5138
5139 /** Called when a route is removed from one of our route groups */
5140 void
5141 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5142 {
5143         update_route_record_state ();
5144         RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
5145 }
5146
5147 boost::shared_ptr<RouteList>
5148 Session::get_tracks () const
5149 {
5150         boost::shared_ptr<RouteList> rl = routes.reader ();
5151         boost::shared_ptr<RouteList> tl (new RouteList);
5152
5153         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
5154                 if (boost::dynamic_pointer_cast<Track> (*r)) {
5155                         if (!(*r)->is_auditioner()) {
5156                                 tl->push_back (*r);
5157                         }
5158                 }
5159         }
5160         return tl;
5161 }
5162
5163 boost::shared_ptr<RouteList>
5164 Session::get_routes_with_regions_at (framepos_t const p) const
5165 {
5166         boost::shared_ptr<RouteList> r = routes.reader ();
5167         boost::shared_ptr<RouteList> rl (new RouteList);
5168
5169         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5170                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5171                 if (!tr) {
5172                         continue;
5173                 }
5174
5175                 boost::shared_ptr<Playlist> pl = tr->playlist ();
5176                 if (!pl) {
5177                         continue;
5178                 }
5179
5180                 if (pl->has_region_at (p)) {
5181                         rl->push_back (*i);
5182                 }
5183         }
5184
5185         return rl;
5186 }
5187
5188 void
5189 Session::goto_end ()
5190 {
5191         if (_session_range_location) {
5192                 request_locate (_session_range_location->end(), false);
5193         } else {
5194                 request_locate (0, false);
5195         }
5196 }
5197
5198 void
5199 Session::goto_start ()
5200 {
5201         if (_session_range_location) {
5202                 request_locate (_session_range_location->start(), false);
5203         } else {
5204                 request_locate (0, false);
5205         }
5206 }
5207
5208 framepos_t
5209 Session::current_start_frame () const
5210 {
5211         return _session_range_location ? _session_range_location->start() : 0;
5212 }
5213
5214 framepos_t
5215 Session::current_end_frame () const
5216 {
5217         return _session_range_location ? _session_range_location->end() : 0;
5218 }
5219
5220 void
5221 Session::add_session_range_location (framepos_t start, framepos_t end)
5222 {
5223         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
5224         _locations->add (_session_range_location);
5225 }
5226
5227 void
5228 Session::step_edit_status_change (bool yn)
5229 {
5230         bool send = false;
5231
5232         bool val = false;
5233         if (yn) {
5234                 send = (_step_editors == 0);
5235                 val = true;
5236
5237                 _step_editors++;
5238         } else {
5239                 send = (_step_editors == 1);
5240                 val = false;
5241
5242                 if (_step_editors > 0) {
5243                         _step_editors--;
5244                 }
5245         }
5246
5247         if (send) {
5248                 StepEditStatusChange (val);
5249         }
5250 }
5251
5252
5253 void
5254 Session::start_time_changed (framepos_t old)
5255 {
5256         /* Update the auto loop range to match the session range
5257            (unless the auto loop range has been changed by the user)
5258         */
5259
5260         Location* s = _locations->session_range_location ();
5261         if (s == 0) {
5262                 return;
5263         }
5264
5265         Location* l = _locations->auto_loop_location ();
5266
5267         if (l && l->start() == old) {
5268                 l->set_start (s->start(), true);
5269         }
5270 }
5271
5272 void
5273 Session::end_time_changed (framepos_t old)
5274 {
5275         /* Update the auto loop range to match the session range
5276            (unless the auto loop range has been changed by the user)
5277         */
5278
5279         Location* s = _locations->session_range_location ();
5280         if (s == 0) {
5281                 return;
5282         }
5283
5284         Location* l = _locations->auto_loop_location ();
5285
5286         if (l && l->end() == old) {
5287                 l->set_end (s->end(), true);
5288         }
5289 }
5290
5291 std::vector<std::string>
5292 Session::source_search_path (DataType type) const
5293 {
5294         Searchpath sp;
5295
5296         if (session_dirs.size() == 1) {
5297                 switch (type) {
5298                 case DataType::AUDIO:
5299                         sp.push_back (_session_dir->sound_path());
5300                         break;
5301                 case DataType::MIDI:
5302                         sp.push_back (_session_dir->midi_path());
5303                         break;
5304                 }
5305         } else {
5306                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5307                         SessionDirectory sdir (i->path);
5308                         switch (type) {
5309                         case DataType::AUDIO:
5310                                 sp.push_back (sdir.sound_path());
5311                                 break;
5312                         case DataType::MIDI:
5313                                 sp.push_back (sdir.midi_path());
5314                                 break;
5315                         }
5316                 }
5317         }
5318
5319         if (type == DataType::AUDIO) {
5320                 const string sound_path_2X = _session_dir->sound_path_2X();
5321                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
5322                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
5323                                 sp.push_back (sound_path_2X);
5324                         }
5325                 }
5326         }
5327
5328         // now check the explicit (possibly user-specified) search path
5329
5330         switch (type) {
5331         case DataType::AUDIO:
5332                 sp += Searchpath(config.get_audio_search_path ());
5333                 break;
5334         case DataType::MIDI:
5335                 sp += Searchpath(config.get_midi_search_path ());
5336                 break;
5337         }
5338
5339         return sp;
5340 }
5341
5342 void
5343 Session::ensure_search_path_includes (const string& path, DataType type)
5344 {
5345         Searchpath sp;
5346
5347         if (path == ".") {
5348                 return;
5349         }
5350
5351         switch (type) {
5352         case DataType::AUDIO:
5353                 sp += Searchpath(config.get_audio_search_path ());
5354                 break;
5355         case DataType::MIDI:
5356                 sp += Searchpath (config.get_midi_search_path ());
5357                 break;
5358         }
5359
5360         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5361                 /* No need to add this new directory if it has the same inode as
5362                    an existing one; checking inode rather than name prevents duplicated
5363                    directories when we are using symlinks.
5364
5365                    On Windows, I think we could just do if (*i == path) here.
5366                 */
5367                 if (PBD::equivalent_paths (*i, path)) {
5368                         return;
5369                 }
5370         }
5371
5372         sp += path;
5373
5374         switch (type) {
5375         case DataType::AUDIO:
5376                 config.set_audio_search_path (sp.to_string());
5377                 break;
5378         case DataType::MIDI:
5379                 config.set_midi_search_path (sp.to_string());
5380                 break;
5381         }
5382 }
5383
5384 void
5385 Session::remove_dir_from_search_path (const string& dir, DataType type)
5386 {
5387         Searchpath sp;
5388
5389         switch (type) {
5390         case DataType::AUDIO:
5391                 sp = Searchpath(config.get_audio_search_path ());
5392                 break;
5393         case DataType::MIDI:
5394                 sp = Searchpath (config.get_midi_search_path ());
5395                 break;
5396         }
5397
5398         sp -= dir;
5399
5400         switch (type) {
5401         case DataType::AUDIO:
5402                 config.set_audio_search_path (sp.to_string());
5403                 break;
5404         case DataType::MIDI:
5405                 config.set_midi_search_path (sp.to_string());
5406                 break;
5407         }
5408
5409 }
5410
5411 boost::shared_ptr<Speakers>
5412 Session::get_speakers()
5413 {
5414         return _speakers;
5415 }
5416
5417 list<string>
5418 Session::unknown_processors () const
5419 {
5420         list<string> p;
5421
5422         boost::shared_ptr<RouteList> r = routes.reader ();
5423         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5424                 list<string> t = (*i)->unknown_processors ();
5425                 copy (t.begin(), t.end(), back_inserter (p));
5426         }
5427
5428         p.sort ();
5429         p.unique ();
5430
5431         return p;
5432 }
5433
5434 void
5435 Session::update_latency (bool playback)
5436 {
5437         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
5438
5439         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
5440                 return;
5441         }
5442
5443         boost::shared_ptr<RouteList> r = routes.reader ();
5444         framecnt_t max_latency = 0;
5445
5446         if (playback) {
5447                 /* reverse the list so that we work backwards from the last route to run to the first */
5448                 RouteList* rl = routes.reader().get();
5449                 r.reset (new RouteList (*rl));
5450                 reverse (r->begin(), r->end());
5451         }
5452
5453         /* compute actual latency values for the given direction and store them all in per-port
5454            structures. this will also publish the same values (to JACK) so that computation of latency
5455            for routes can consistently use public latency values.
5456         */
5457
5458         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5459                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
5460         }
5461
5462         /* because we latency compensate playback, our published playback latencies should
5463            be the same for all output ports - all material played back by ardour has
5464            the same latency, whether its caused by plugins or by latency compensation. since
5465            these may differ from the values computed above, reset all playback port latencies
5466            to the same value.
5467         */
5468
5469         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
5470
5471         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5472                 (*i)->set_public_port_latencies (max_latency, playback);
5473         }
5474
5475         if (playback) {
5476
5477                 post_playback_latency ();
5478
5479         } else {
5480
5481                 post_capture_latency ();
5482         }
5483
5484         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
5485 }
5486
5487 void
5488 Session::post_playback_latency ()
5489 {
5490         set_worst_playback_latency ();
5491
5492         boost::shared_ptr<RouteList> r = routes.reader ();
5493
5494         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5495                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5496                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
5497                 }
5498         }
5499
5500         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5501                 (*i)->set_latency_compensation (_worst_track_latency);
5502         }
5503 }
5504
5505 void
5506 Session::post_capture_latency ()
5507 {
5508         set_worst_capture_latency ();
5509
5510         /* reflect any changes in capture latencies into capture offsets
5511          */
5512
5513         boost::shared_ptr<RouteList> rl = routes.reader();
5514         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5515                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5516                 if (tr) {
5517                         tr->set_capture_offset ();
5518                 }
5519         }
5520 }
5521
5522 void
5523 Session::initialize_latencies ()
5524 {
5525         {
5526                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5527                 update_latency (false);
5528                 update_latency (true);
5529         }
5530
5531         set_worst_io_latencies ();
5532 }
5533
5534 void
5535 Session::set_worst_io_latencies ()
5536 {
5537         set_worst_playback_latency ();
5538         set_worst_capture_latency ();
5539 }
5540
5541 void
5542 Session::set_worst_playback_latency ()
5543 {
5544         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5545                 return;
5546         }
5547
5548         _worst_output_latency = 0;
5549
5550         if (!_engine.connected()) {
5551                 return;
5552         }
5553
5554         boost::shared_ptr<RouteList> r = routes.reader ();
5555
5556         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5557                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5558         }
5559
5560         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5561 }
5562
5563 void
5564 Session::set_worst_capture_latency ()
5565 {
5566         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5567                 return;
5568         }
5569
5570         _worst_input_latency = 0;
5571
5572         if (!_engine.connected()) {
5573                 return;
5574         }
5575
5576         boost::shared_ptr<RouteList> r = routes.reader ();
5577
5578         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5579                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
5580         }
5581
5582         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
5583 }
5584
5585 void
5586 Session::update_latency_compensation (bool force_whole_graph)
5587 {
5588         bool some_track_latency_changed = false;
5589
5590         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5591                 return;
5592         }
5593
5594         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
5595
5596         _worst_track_latency = 0;
5597
5598         boost::shared_ptr<RouteList> r = routes.reader ();
5599
5600         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5601                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5602                         framecnt_t tl;
5603                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
5604                                 some_track_latency_changed = true;
5605                         }
5606                         _worst_track_latency = max (tl, _worst_track_latency);
5607                 }
5608         }
5609
5610         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
5611                                                      (some_track_latency_changed ? "yes" : "no")));
5612
5613         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
5614
5615         if (some_track_latency_changed || force_whole_graph)  {
5616                 _engine.update_latencies ();
5617         }
5618
5619
5620         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5621                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5622                 if (!tr) {
5623                         continue;
5624                 }
5625                 tr->set_capture_offset ();
5626         }
5627 }
5628
5629 char
5630 Session::session_name_is_legal (const string& path)
5631 {
5632         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
5633
5634         for (int i = 0; illegal_chars[i]; ++i) {
5635                 if (path.find (illegal_chars[i]) != string::npos) {
5636                         return illegal_chars[i];
5637                 }
5638         }
5639
5640         return 0;
5641 }
5642
5643 uint32_t
5644 Session::next_control_id () const
5645 {
5646         int subtract = 0;
5647
5648         /* the monitor bus remote ID is in a different
5649          * "namespace" than regular routes. its existence doesn't
5650          * affect normal (low) numbered routes.
5651          */
5652
5653         if (_monitor_out) {
5654                 subtract++;
5655         }
5656
5657         return nroutes() - subtract;
5658 }
5659
5660 void
5661 Session::notify_remote_id_change ()
5662 {
5663         if (deletion_in_progress()) {
5664                 return;
5665         }
5666
5667         switch (Config->get_remote_model()) {
5668         case MixerOrdered:
5669                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
5670                 break;
5671         default:
5672                 break;
5673         }
5674 }
5675
5676 void
5677 Session::sync_order_keys ()
5678 {
5679         if (deletion_in_progress()) {
5680                 return;
5681         }
5682
5683         /* tell everyone that something has happened to the sort keys
5684            and let them sync up with the change(s)
5685            this will give objects that manage the sort order keys the
5686            opportunity to keep them in sync if they wish to.
5687         */
5688
5689         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
5690
5691         reassign_track_numbers();
5692
5693         Route::SyncOrderKeys (); /* EMIT SIGNAL */
5694
5695         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
5696 }
5697
5698 bool
5699 Session::operation_in_progress (GQuark op) const
5700 {
5701         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
5702 }
5703
5704 boost::shared_ptr<Port>
5705 Session::ltc_input_port () const
5706 {
5707         return _ltc_input->nth (0);
5708 }
5709
5710 boost::shared_ptr<Port>
5711 Session::ltc_output_port () const
5712 {
5713         return _ltc_output->nth (0);
5714 }
5715
5716 void
5717 Session::reconnect_ltc_input ()
5718 {
5719         if (_ltc_input) {
5720
5721                 string src = Config->get_ltc_source_port();
5722
5723                 _ltc_input->disconnect (this);
5724
5725                 if (src != _("None") && !src.empty())  {
5726                         _ltc_input->nth (0)->connect (src);
5727                 }
5728         }
5729 }
5730
5731 void
5732 Session::reconnect_ltc_output ()
5733 {
5734         if (_ltc_output) {
5735
5736 #if 0
5737                 string src = Config->get_ltc_sink_port();
5738
5739                 _ltc_output->disconnect (this);
5740
5741                 if (src != _("None") && !src.empty())  {
5742                         _ltc_output->nth (0)->connect (src);
5743                 }
5744 #endif
5745         }
5746 }