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