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