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