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         , _locations (new Locations (*this))
 212         , _ignore_skips_updates (false)
 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
1485         for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1486                 location_added (*i);
1487         }
1488 }
1489
1490 void
1491 Session::enable_record ()
1492 {
1493         if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1494                 /* no recording at anything except normal speed */
1495                 return;
1496         }
1497
1498         while (1) {
1499                 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1500
1501                 if (rs == Recording) {
1502                         break;
1503                 }
1504
1505                 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1506
1507                         _last_record_location = _transport_frame;
1508                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1509
1510                         if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1511                                 set_track_monitor_input_status (true);
1512                         }
1513
1514                         RecordStateChanged ();
1515                         break;
1516                 }
1517         }
1518 }
1519
1520 void
1521 Session::disable_record (bool rt_context, bool force)
1522 {
1523         RecordState rs;
1524
1525         if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1526
1527                 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1528                         g_atomic_int_set (&_record_status, Disabled);
1529                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1530                 } else {
1531                         if (rs == Recording) {
1532                                 g_atomic_int_set (&_record_status, Enabled);
1533                         }
1534                 }
1535
1536                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1537                         set_track_monitor_input_status (false);
1538                 }
1539
1540                 RecordStateChanged (); /* emit signal */
1541
1542                 if (!rt_context) {
1543                         remove_pending_capture_state ();
1544                 }
1545         }
1546 }
1547
1548 void
1549 Session::step_back_from_record ()
1550 {
1551         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1552
1553                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1554                         set_track_monitor_input_status (false);
1555                 }
1556
1557                 RecordStateChanged (); /* emit signal */
1558         }
1559 }
1560
1561 void
1562 Session::maybe_enable_record ()
1563 {
1564         if (_step_editors > 0) {
1565                 return;
1566         }
1567
1568         g_atomic_int_set (&_record_status, Enabled);
1569
1570         /* This function is currently called from somewhere other than an RT thread.
1571            This save_state() call therefore doesn't impact anything.  Doing it here
1572            means that we save pending state of which sources the next record will use,
1573            which gives us some chance of recovering from a crash during the record.
1574         */
1575
1576         save_state ("", true);
1577
1578         if (_transport_speed) {
1579                 if (!config.get_punch_in()) {
1580                         enable_record ();
1581                 }
1582         } else {
1583                 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1584                 RecordStateChanged (); /* EMIT SIGNAL */
1585         }
1586
1587         set_dirty();
1588 }
1589
1590 framepos_t
1591 Session::audible_frame () const
1592 {
1593         framepos_t ret;
1594         framepos_t tf;
1595         framecnt_t offset;
1596
1597         offset = worst_playback_latency ();
1598
1599         if (synced_to_engine()) {
1600                 /* Note: this is basically just sync-to-JACK */
1601                 tf = _engine.transport_frame();
1602         } else {
1603                 tf = _transport_frame;
1604         }
1605
1606         ret = tf;
1607
1608         if (!non_realtime_work_pending()) {
1609
1610                 /* MOVING */
1611
1612                 /* Check to see if we have passed the first guaranteed
1613                    audible frame past our last start position. if not,
1614                    return that last start point because in terms
1615                    of audible frames, we have not moved yet.
1616
1617                    `Start position' in this context means the time we last
1618                    either started, located, or changed transport direction.
1619                 */
1620
1621                 if (_transport_speed > 0.0f) {
1622
1623                         if (!play_loop || !have_looped) {
1624                                 if (tf < _last_roll_or_reversal_location + offset) {
1625                                         return _last_roll_or_reversal_location;
1626                                 }
1627                         }
1628
1629
1630                         /* forwards */
1631                         ret -= offset;
1632
1633                 } else if (_transport_speed < 0.0f) {
1634
1635                         /* XXX wot? no backward looping? */
1636
1637                         if (tf > _last_roll_or_reversal_location - offset) {
1638                                 return _last_roll_or_reversal_location;
1639                         } else {
1640                                 /* backwards */
1641                                 ret += offset;
1642                         }
1643                 }
1644         }
1645
1646         return ret;
1647 }
1648
1649 void
1650 Session::set_frame_rate (framecnt_t frames_per_second)
1651 {
1652         /** \fn void Session::set_frame_size(framecnt_t)
1653                 the AudioEngine object that calls this guarantees
1654                 that it will not be called while we are also in
1655                 ::process(). Its fine to do things that block
1656                 here.
1657         */
1658
1659         _base_frame_rate = frames_per_second;
1660         _nominal_frame_rate = frames_per_second;
1661
1662         sync_time_vars();
1663
1664         clear_clicks ();
1665
1666         // XXX we need some equivalent to this, somehow
1667         // SndFileSource::setup_standard_crossfades (frames_per_second);
1668
1669         set_dirty();
1670
1671         /* XXX need to reset/reinstantiate all LADSPA plugins */
1672 }
1673
1674 void
1675 Session::set_block_size (pframes_t nframes)
1676 {
1677         /* the AudioEngine guarantees
1678            that it will not be called while we are also in
1679            ::process(). It is therefore fine to do things that block
1680            here.
1681         */
1682
1683         {
1684                 current_block_size = nframes;
1685
1686                 ensure_buffers ();
1687
1688                 boost::shared_ptr<RouteList> r = routes.reader ();
1689
1690                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1691                         (*i)->set_block_size (nframes);
1692                 }
1693
1694                 boost::shared_ptr<RouteList> rl = routes.reader ();
1695                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1696                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1697                         if (tr) {
1698                                 tr->set_block_size (nframes);
1699                         }
1700                 }
1701
1702                 set_worst_io_latencies ();
1703         }
1704 }
1705
1706
1707 static void
1708 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1709 {
1710         boost::shared_ptr<Route> r2;
1711
1712         if (r1->feeds (rbase) && rbase->feeds (r1)) {
1713                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1714                 return;
1715         }
1716
1717         /* make a copy of the existing list of routes that feed r1 */
1718
1719         Route::FedBy existing (r1->fed_by());
1720
1721         /* for each route that feeds r1, recurse, marking it as feeding
1722            rbase as well.
1723         */
1724
1725         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1726                 if (!(r2 = i->r.lock ())) {
1727                         /* (*i) went away, ignore it */
1728                         continue;
1729                 }
1730
1731                 /* r2 is a route that feeds r1 which somehow feeds base. mark
1732                    base as being fed by r2
1733                 */
1734
1735                 rbase->add_fed_by (r2, i->sends_only);
1736
1737                 if (r2 != rbase) {
1738
1739                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1740                            stop here.
1741                         */
1742
1743                         if (r1->feeds (r2) && r2->feeds (r1)) {
1744                                 continue;
1745                         }
1746
1747                         /* now recurse, so that we can mark base as being fed by
1748                            all routes that feed r2
1749                         */
1750
1751                         trace_terminal (r2, rbase);
1752                 }
1753
1754         }
1755 }
1756
1757 void
1758 Session::resort_routes ()
1759 {
1760         /* don't do anything here with signals emitted
1761            by Routes during initial setup or while we
1762            are being destroyed.
1763         */
1764
1765         if (_state_of_the_state & (InitialConnecting | Deletion)) {
1766                 return;
1767         }
1768
1769         {
1770                 RCUWriter<RouteList> writer (routes);
1771                 boost::shared_ptr<RouteList> r = writer.get_copy ();
1772                 resort_routes_using (r);
1773                 /* writer goes out of scope and forces update */
1774         }
1775
1776 #ifndef NDEBUG
1777         boost::shared_ptr<RouteList> rl = routes.reader ();
1778         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1779                 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1780
1781                 const Route::FedBy& fb ((*i)->fed_by());
1782
1783                 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1784                         boost::shared_ptr<Route> sf = f->r.lock();
1785                         if (sf) {
1786                                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1787                         }
1788                 }
1789         }
1790 #endif
1791
1792 }
1793
1794 /** This is called whenever we need to rebuild the graph of how we will process
1795  *  routes.
1796  *  @param r List of routes, in any order.
1797  */
1798
1799 void
1800 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1801 {
1802         /* We are going to build a directed graph of our routes;
1803            this is where the edges of that graph are put.
1804         */
1805
1806         GraphEdges edges;
1807
1808         /* Go through all routes doing two things:
1809          *
1810          * 1. Collect the edges of the route graph.  Each of these edges
1811          *    is a pair of routes, one of which directly feeds the other
1812          *    either by a JACK connection or by an internal send.
1813          *
1814          * 2. Begin the process of making routes aware of which other
1815          *    routes directly or indirectly feed them.  This information
1816          *    is used by the solo code.
1817          */
1818
1819         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1820
1821                 /* Clear out the route's list of direct or indirect feeds */
1822                 (*i)->clear_fed_by ();
1823
1824                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1825
1826                         bool via_sends_only;
1827
1828                         /* See if this *j feeds *i according to the current state of the JACK
1829                            connections and internal sends.
1830                         */
1831                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1832                                 /* add the edge to the graph (part #1) */
1833                                 edges.add (*j, *i, via_sends_only);
1834                                 /* tell the route (for part #2) */
1835                                 (*i)->add_fed_by (*j, via_sends_only);
1836                         }
1837                 }
1838         }
1839
1840         /* Attempt a topological sort of the route graph */
1841         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1842
1843         if (sorted_routes) {
1844                 /* We got a satisfactory topological sort, so there is no feedback;
1845                    use this new graph.
1846
1847                    Note: the process graph rechain does not require a
1848                    topologically-sorted list, but hey ho.
1849                 */
1850                 if (_process_graph) {
1851                         _process_graph->rechain (sorted_routes, edges);
1852                 }
1853
1854                 _current_route_graph = edges;
1855
1856                 /* Complete the building of the routes' lists of what directly
1857                    or indirectly feeds them.
1858                 */
1859                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1860                         trace_terminal (*i, *i);
1861                 }
1862
1863                 *r = *sorted_routes;
1864
1865 #ifndef NDEBUG
1866                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1867                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1868                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1869                                                                    (*i)->name(), (*i)->order_key ()));
1870                 }
1871 #endif
1872
1873                 SuccessfulGraphSort (); /* EMIT SIGNAL */
1874
1875         } else {
1876                 /* The topological sort failed, so we have a problem.  Tell everyone
1877                    and stick to the old graph; this will continue to be processed, so
1878                    until the feedback is fixed, what is played back will not quite
1879                    reflect what is actually connected.  Note also that we do not
1880                    do trace_terminal here, as it would fail due to an endless recursion,
1881                    so the solo code will think that everything is still connected
1882                    as it was before.
1883                 */
1884
1885                 FeedbackDetected (); /* EMIT SIGNAL */
1886         }
1887
1888 }
1889
1890 /** Find a route name starting with \a base, maybe followed by the
1891  *  lowest \a id.  \a id will always be added if \a definitely_add_number
1892  *  is true on entry; otherwise it will only be added if required
1893  *  to make the name unique.
1894  *
1895  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1896  *  The available route name with the lowest ID will be used, and \a id
1897  *  will be set to the ID.
1898  *
1899  *  \return false if a route name could not be found, and \a track_name
1900  *  and \a id do not reflect a free route name.
1901  */
1902 bool
1903 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1904 {
1905         if (!definitely_add_number && route_by_name (base) == 0) {
1906                 /* juse use the base */
1907                 snprintf (name, name_len, "%s", base.c_str());
1908                 return true;
1909         }
1910
1911         do {
1912                 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1913
1914                 if (route_by_name (name) == 0) {
1915                         return true;
1916                 }
1917
1918                 ++id;
1919
1920         } while (id < (UINT_MAX-1));
1921
1922         return false;
1923 }
1924
1925 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1926 void
1927 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1928 {
1929         in  = ChanCount::ZERO;
1930         out = ChanCount::ZERO;
1931
1932         boost::shared_ptr<RouteList> r = routes.reader ();
1933
1934         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1935                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1936                 if (tr && !tr->is_auditioner()) {
1937                         in  += tr->n_inputs();
1938                         out += tr->n_outputs();
1939                 }
1940         }
1941 }
1942
1943 /** Caller must not hold process lock
1944  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
1945  *  @param instrument plugin info for the instrument to insert pre-fader, if any
1946  */
1947 list<boost::shared_ptr<MidiTrack> >
1948 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1949                          TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1950 {
1951         char track_name[32];
1952         uint32_t track_id = 0;
1953         string port;
1954         RouteList new_routes;
1955         list<boost::shared_ptr<MidiTrack> > ret;
1956
1957         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1958
1959         while (how_many) {
1960                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1961                         error << "cannot find name for new midi track" << endmsg;
1962                         goto failed;
1963                 }
1964
1965                 boost::shared_ptr<MidiTrack> track;
1966
1967                 try {
1968                         track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1969
1970                         if (track->init ()) {
1971                                 goto failed;
1972                         }
1973
1974                         track->use_new_diskstream();
1975
1976 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1977                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1978 #endif
1979                         {
1980                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1981                                 if (track->input()->ensure_io (input, false, this)) {
1982                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1983                                         goto failed;
1984                                 }
1985
1986                                 if (track->output()->ensure_io (output, false, this)) {
1987                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1988                                         goto failed;
1989                                 }
1990                         }
1991
1992                         track->non_realtime_input_change();
1993
1994                         if (route_group) {
1995                                 route_group->add (track);
1996                         }
1997
1998                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1999
2000                         if (Config->get_remote_model() == UserOrdered) {
2001                                 track->set_remote_control_id (next_control_id());
2002                         }
2003
2004                         new_routes.push_back (track);
2005                         ret.push_back (track);
2006                 }
2007
2008                 catch (failed_constructor &err) {
2009                         error << _("Session: could not create new midi track.") << endmsg;
2010                         goto failed;
2011                 }
2012
2013                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2014
2015                         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;
2016                         goto failed;
2017                 }
2018
2019                 --how_many;
2020         }
2021
2022   failed:
2023         if (!new_routes.empty()) {
2024                 StateProtector sp (this);
2025                 add_routes (new_routes, true, true, true);
2026
2027                 if (instrument) {
2028                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2029                                 PluginPtr plugin = instrument->load (*this);
2030                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2031                                 (*r)->add_processor (p, PreFader);
2032
2033                         }
2034                 }
2035         }
2036
2037         return ret;
2038 }
2039
2040 void
2041 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2042 {
2043         boost::shared_ptr<Route> midi_track (wmt.lock());
2044
2045         if (!midi_track) {
2046                 return;
2047         }
2048
2049         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2050
2051                 if (change.after.n_audio() <= change.before.n_audio()) {
2052                         return;
2053                 }
2054
2055                 /* new audio ports: make sure the audio goes somewhere useful,
2056                    unless the user has no-auto-connect selected.
2057
2058                    The existing ChanCounts don't matter for this call as they are only
2059                    to do with matching input and output indices, and we are only changing
2060                    outputs here.
2061                 */
2062
2063                 ChanCount dummy;
2064
2065                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
2066         }
2067 }
2068
2069 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
2070  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
2071  *  @param output_start As \a input_start, but for outputs.
2072  */
2073 void
2074 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
2075                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
2076 {
2077         if (!IO::connecting_legal) {
2078                 return;
2079         }
2080
2081         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2082
2083         if (with_lock) {
2084                 lm.acquire ();
2085         }
2086
2087         /* If both inputs and outputs are auto-connected to physical ports,
2088            use the max of input and output offsets to ensure auto-connected
2089            port numbers always match up (e.g. the first audio input and the
2090            first audio output of the route will have the same physical
2091            port number).  Otherwise just use the lowest input or output
2092            offset possible.
2093         */
2094
2095         DEBUG_TRACE (DEBUG::Graph,
2096                      string_compose("Auto-connect: existing in = %1 out = %2\n",
2097                                     existing_inputs, existing_outputs));
2098
2099         const bool in_out_physical =
2100                 (Config->get_input_auto_connect() & AutoConnectPhysical)
2101                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
2102                 && connect_inputs;
2103
2104         const ChanCount in_offset = in_out_physical
2105                 ? ChanCount::max(existing_inputs, existing_outputs)
2106                 : existing_inputs;
2107
2108         const ChanCount out_offset = in_out_physical
2109                 ? ChanCount::max(existing_inputs, existing_outputs)
2110                 : existing_outputs;
2111
2112         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2113                 vector<string> physinputs;
2114                 vector<string> physoutputs;
2115
2116                 _engine.get_physical_outputs (*t, physoutputs);
2117                 _engine.get_physical_inputs (*t, physinputs);
2118
2119                 if (!physinputs.empty() && connect_inputs) {
2120                         uint32_t nphysical_in = physinputs.size();
2121
2122                         DEBUG_TRACE (DEBUG::Graph,
2123                                      string_compose("There are %1 physical inputs of type %2\n",
2124                                                     nphysical_in, *t));
2125
2126                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
2127                                 string port;
2128
2129                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
2130                                         DEBUG_TRACE (DEBUG::Graph,
2131                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
2132                                                                     in_offset.get(*t), i, nphysical_in,
2133                                                                     (in_offset.get(*t) + i) % nphysical_in));
2134                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
2135                                 }
2136
2137                                 DEBUG_TRACE (DEBUG::Graph,
2138                                              string_compose("Connect route %1 IN to %2\n",
2139                                                             route->name(), port));
2140
2141                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
2142                                         break;
2143                                 }
2144
2145                                 ChanCount one_added (*t, 1);
2146                                 existing_inputs += one_added;
2147                         }
2148                 }
2149
2150                 if (!physoutputs.empty()) {
2151                         uint32_t nphysical_out = physoutputs.size();
2152                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
2153                                 string port;
2154
2155                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
2156                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
2157                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
2158                                         /* master bus is audio only */
2159                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
2160                                                 port = _master_out->input()->ports().port(*t,
2161                                                                 i % _master_out->input()->n_ports().get(*t))->name();
2162                                         }
2163                                 }
2164
2165                                 DEBUG_TRACE (DEBUG::Graph,
2166                                              string_compose("Connect route %1 OUT to %2\n",
2167                                                             route->name(), port));
2168
2169                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2170                                         break;
2171                                 }
2172
2173                                 ChanCount one_added (*t, 1);
2174                                 existing_outputs += one_added;
2175                         }
2176                 }
2177         }
2178 }
2179
2180 void
2181 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2182 {
2183         /* TRX does stuff here, ardour does not (but probably should). This is called after an engine reset (in particular).
2184          */
2185 }
2186
2187
2188 /** Caller must not hold process lock
2189  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2190  */
2191 list< boost::shared_ptr<AudioTrack> >
2192 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2193                           uint32_t how_many, string name_template)
2194 {
2195         char track_name[32];
2196         uint32_t track_id = 0;
2197         string port;
2198         RouteList new_routes;
2199         list<boost::shared_ptr<AudioTrack> > ret;
2200
2201         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
2202
2203         while (how_many) {
2204                 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2205                         error << "cannot find name for new audio track" << endmsg;
2206                         goto failed;
2207                 }
2208
2209                 boost::shared_ptr<AudioTrack> track;
2210
2211                 try {
2212                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2213
2214                         if (track->init ()) {
2215                                 goto failed;
2216                         }
2217
2218                         track->use_new_diskstream();
2219
2220 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2221                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2222 #endif
2223                         {
2224                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2225
2226                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2227                                         error << string_compose (
2228                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2229                                                 input_channels, output_channels)
2230                                               << endmsg;
2231                                         goto failed;
2232                                 }
2233
2234                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_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
2243                         if (route_group) {
2244                                 route_group->add (track);
2245                         }
2246
2247                         track->non_realtime_input_change();
2248
2249                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2250                         if (Config->get_remote_model() == UserOrdered) {
2251                                 track->set_remote_control_id (next_control_id());
2252                         }
2253
2254                         new_routes.push_back (track);
2255                         ret.push_back (track);
2256                 }
2257
2258                 catch (failed_constructor &err) {
2259                         error << _("Session: could not create new audio track.") << endmsg;
2260                         goto failed;
2261                 }
2262
2263                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2264
2265                         error << pfe.what() << endmsg;
2266                         goto failed;
2267                 }
2268
2269                 --how_many;
2270         }
2271
2272   failed:
2273         if (!new_routes.empty()) {
2274                 StateProtector sp (this);
2275                 add_routes (new_routes, true, true, true);
2276         }
2277
2278         return ret;
2279 }
2280
2281 /** Caller must not hold process lock.
2282  *  @param name_template string to use for the start of the name, or "" to use "Bus".
2283  */
2284 RouteList
2285 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2286 {
2287         char bus_name[32];
2288         uint32_t bus_id = 0;
2289         string port;
2290         RouteList ret;
2291
2292         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2293
2294         while (how_many) {
2295                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2296                         error << "cannot find name for new audio bus" << endmsg;
2297                         goto failure;
2298                 }
2299
2300                 try {
2301                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2302
2303                         if (bus->init ()) {
2304                                 goto failure;
2305                         }
2306
2307 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2308                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2309 #endif
2310                         {
2311                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2312
2313                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2314                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2315                                                                  input_channels, output_channels)
2316                                               << endmsg;
2317                                         goto failure;
2318                                 }
2319
2320
2321                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_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 (route_group) {
2330                                 route_group->add (bus);
2331                         }
2332                         if (Config->get_remote_model() == UserOrdered) {
2333                                 bus->set_remote_control_id (next_control_id());
2334                         }
2335
2336                         bus->add_internal_return ();
2337
2338                         ret.push_back (bus);
2339
2340                         ARDOUR::GUIIdle ();
2341                 }
2342
2343
2344                 catch (failed_constructor &err) {
2345                         error << _("Session: could not create new audio route.") << endmsg;
2346                         goto failure;
2347                 }
2348
2349                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2350                         error << pfe.what() << endmsg;
2351                         goto failure;
2352                 }
2353
2354
2355                 --how_many;
2356         }
2357
2358   failure:
2359         if (!ret.empty()) {
2360                 StateProtector sp (this);
2361                 add_routes (ret, false, true, true); // autoconnect outputs only
2362         }
2363
2364         return ret;
2365
2366 }
2367
2368 RouteList
2369 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2370 {
2371         RouteList ret;
2372         uint32_t control_id;
2373         XMLTree tree;
2374         uint32_t number = 0;
2375         const uint32_t being_added = how_many;
2376
2377         if (!tree.read (template_path.c_str())) {
2378                 return ret;
2379         }
2380
2381         XMLNode* node = tree.root();
2382
2383         IO::disable_connecting ();
2384
2385         control_id = next_control_id ();
2386
2387         while (how_many) {
2388
2389                 XMLNode node_copy (*node);
2390
2391                 /* Remove IDs of everything so that new ones are used */
2392                 node_copy.remove_property_recursively (X_("id"));
2393
2394                 try {
2395                         char name[32];
2396
2397                         if (!name_base.empty()) {
2398
2399                                 /* if we're adding more than one routes, force
2400                                  * all the names of the new routes to be
2401                                  * numbered, via the final parameter.
2402                                  */
2403
2404                                 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2405                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2406                                         /*NOTREACHDE*/
2407                                 }
2408
2409                         } else {
2410
2411                                 string const route_name  = node_copy.property(X_("name"))->value ();
2412
2413                                 /* generate a new name by adding a number to the end of the template name */
2414                                 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2415                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2416                                         abort(); /*NOTREACHED*/
2417                                 }
2418                         }
2419
2420                         /* set this name in the XML description that we are about to use */
2421                         Route::set_name_in_state (node_copy, name);
2422
2423                         /* trim bitslots from listen sends so that new ones are used */
2424                         XMLNodeList children = node_copy.children ();
2425                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2426                                 if ((*i)->name() == X_("Processor")) {
2427                                         XMLProperty* role = (*i)->property (X_("role"));
2428                                         if (role && role->value() == X_("Listen")) {
2429                                                 (*i)->remove_property (X_("bitslot"));
2430                                         }
2431                                 }
2432                         }
2433
2434                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2435
2436                         if (route == 0) {
2437                                 error << _("Session: cannot create track/bus from template description") << endmsg;
2438                                 goto out;
2439                         }
2440
2441                         if (boost::dynamic_pointer_cast<Track>(route)) {
2442                                 /* force input/output change signals so that the new diskstream
2443                                    picks up the configuration of the route. During session
2444                                    loading this normally happens in a different way.
2445                                 */
2446
2447                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2448
2449                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2450                                 change.after = route->input()->n_ports();
2451                                 route->input()->changed (change, this);
2452                                 change.after = route->output()->n_ports();
2453                                 route->output()->changed (change, this);
2454                         }
2455
2456                         route->set_remote_control_id (control_id);
2457                         ++control_id;
2458
2459                         ret.push_back (route);
2460                 }
2461
2462                 catch (failed_constructor &err) {
2463                         error << _("Session: could not create new route from template") << endmsg;
2464                         goto out;
2465                 }
2466
2467                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2468                         error << pfe.what() << endmsg;
2469                         goto out;
2470                 }
2471
2472                 --how_many;
2473         }
2474
2475   out:
2476         if (!ret.empty()) {
2477                 StateProtector sp (this);
2478                 add_routes (ret, true, true, true);
2479                 IO::enable_connecting ();
2480         }
2481
2482         return ret;
2483 }
2484
2485 void
2486 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2487 {
2488         try {
2489                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2490                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2491
2492         } catch (...) {
2493                 error << _("Adding new tracks/busses failed") << endmsg;
2494         }
2495
2496         graph_reordered ();
2497
2498         update_latency (true);
2499         update_latency (false);
2500
2501         set_dirty();
2502
2503         if (save) {
2504                 save_state (_current_snapshot_name);
2505         }
2506
2507         reassign_track_numbers();
2508
2509         RouteAdded (new_routes); /* EMIT SIGNAL */
2510 }
2511
2512 void
2513 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2514 {
2515         ChanCount existing_inputs;
2516         ChanCount existing_outputs;
2517         uint32_t order = next_control_id();
2518
2519         if (_order_hint != 0) {
2520                 order = _order_hint;
2521                 _order_hint = 0;
2522         }
2523
2524         count_existing_track_channels (existing_inputs, existing_outputs);
2525
2526         {
2527                 RCUWriter<RouteList> writer (routes);
2528                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2529                 r->insert (r->end(), new_routes.begin(), new_routes.end());
2530
2531                 /* if there is no control out and we're not in the middle of loading,
2532                    resort the graph here. if there is a control out, we will resort
2533                    toward the end of this method. if we are in the middle of loading,
2534                    we will resort when done.
2535                 */
2536
2537                 if (!_monitor_out && IO::connecting_legal) {
2538                         resort_routes_using (r);
2539                 }
2540         }
2541
2542         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2543
2544                 boost::weak_ptr<Route> wpr (*x);
2545                 boost::shared_ptr<Route> r (*x);
2546
2547                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2548                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2549                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2550                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2551                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2552                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2553
2554                 if (r->is_master()) {
2555                         _master_out = r;
2556                 }
2557
2558                 if (r->is_monitor()) {
2559                         _monitor_out = r;
2560                 }
2561
2562                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2563                 if (tr) {
2564                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2565                         track_playlist_changed (boost::weak_ptr<Track> (tr));
2566                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2567
2568                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2569                         if (mt) {
2570                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2571                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2572                         }
2573                 }
2574
2575
2576                 if (input_auto_connect || output_auto_connect) {
2577                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2578                 }
2579
2580                 /* order keys are a GUI responsibility but we need to set up
2581                    reasonable defaults because they also affect the remote control
2582                    ID in most situations.
2583                 */
2584
2585                 if (!r->has_order_key ()) {
2586                         if (r->is_auditioner()) {
2587                                 /* use an arbitrarily high value */
2588                                 r->set_order_key (UINT_MAX);
2589                         } else {
2590                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2591                                 r->set_order_key (order);
2592                                 order++;
2593                         }
2594                 }
2595
2596                 ARDOUR::GUIIdle ();
2597         }
2598
2599         if (_monitor_out && IO::connecting_legal) {
2600                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2601
2602                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2603                         if ((*x)->is_monitor()) {
2604                                 /* relax */
2605                         } else if ((*x)->is_master()) {
2606                                         /* relax */
2607                         } else {
2608                                 (*x)->enable_monitor_send ();
2609                         }
2610                 }
2611         }
2612 }
2613
2614 void
2615 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2616 {
2617         boost::shared_ptr<RouteList> r = routes.reader ();
2618         boost::shared_ptr<Send> s;
2619
2620         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2621                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2622                         s->amp()->gain_control()->set_value (0.0);
2623                 }
2624         }
2625 }
2626
2627 void
2628 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2629 {
2630         boost::shared_ptr<RouteList> r = routes.reader ();
2631         boost::shared_ptr<Send> s;
2632
2633         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2634                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2635                         s->amp()->gain_control()->set_value (1.0);
2636                 }
2637         }
2638 }
2639
2640 void
2641 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2642 {
2643         boost::shared_ptr<RouteList> r = routes.reader ();
2644         boost::shared_ptr<Send> s;
2645
2646         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2647                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2648                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2649                 }
2650         }
2651 }
2652
2653 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2654 void
2655 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2656 {
2657         boost::shared_ptr<RouteList> r = routes.reader ();
2658         boost::shared_ptr<RouteList> t (new RouteList);
2659
2660         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2661                 /* no MIDI sends because there are no MIDI busses yet */
2662                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2663                         t->push_back (*i);
2664                 }
2665         }
2666
2667         add_internal_sends (dest, p, t);
2668 }
2669
2670 void
2671 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2672 {
2673         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2674                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2675         }
2676 }
2677
2678 void
2679 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2680 {
2681         add_internal_send (dest, sender->before_processor_for_index (index), sender);
2682 }
2683
2684 void
2685 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2686 {
2687         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2688                 return;
2689         }
2690
2691         if (!dest->internal_return()) {
2692                 dest->add_internal_return ();
2693         }
2694
2695         sender->add_aux_send (dest, before);
2696
2697         graph_reordered ();
2698 }
2699
2700 void
2701 Session::remove_route (boost::shared_ptr<Route> route)
2702 {
2703         if (route == _master_out) {
2704                 return;
2705         }
2706
2707         route->set_solo (false, this);
2708
2709         {
2710                 RCUWriter<RouteList> writer (routes);
2711                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2712
2713                 rs->remove (route);
2714
2715                 /* deleting the master out seems like a dumb
2716                    idea, but its more of a UI policy issue
2717                    than our concern.
2718                 */
2719
2720                 if (route == _master_out) {
2721                         _master_out = boost::shared_ptr<Route> ();
2722                 }
2723
2724                 if (route == _monitor_out) {
2725                         _monitor_out.reset ();
2726                 }
2727
2728                 /* writer goes out of scope, forces route list update */
2729         }
2730
2731         update_route_solo_state ();
2732
2733         // We need to disconnect the route's inputs and outputs
2734
2735         route->input()->disconnect (0);
2736         route->output()->disconnect (0);
2737
2738         /* if the route had internal sends sending to it, remove them */
2739         if (route->internal_return()) {
2740
2741                 boost::shared_ptr<RouteList> r = routes.reader ();
2742                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2743                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2744                         if (s) {
2745                                 (*i)->remove_processor (s);
2746                         }
2747                 }
2748         }
2749
2750         /* if the monitoring section had a pointer to this route, remove it */
2751         if (_monitor_out && !route->is_master() && !route->is_monitor()) {
2752                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2753                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
2754                 route->remove_aux_or_listen (_monitor_out);
2755         }
2756
2757         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2758         if (mt && mt->step_editing()) {
2759                 if (_step_editors > 0) {
2760                         _step_editors--;
2761                 }
2762         }
2763
2764         update_latency_compensation ();
2765         set_dirty();
2766
2767         /* Re-sort routes to remove the graph's current references to the one that is
2768          * going away, then flush old references out of the graph.
2769          */
2770
2771         resort_routes ();
2772         if (_process_graph) {
2773                 _process_graph->clear_other_chain ();
2774         }
2775
2776         /* get rid of it from the dead wood collection in the route list manager */
2777
2778         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2779
2780         routes.flush ();
2781
2782         /* try to cause everyone to drop their references */
2783
2784         route->drop_references ();
2785
2786         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2787
2788         /* save the new state of the world */
2789
2790         if (save_state (_current_snapshot_name)) {
2791                 save_history (_current_snapshot_name);
2792         }
2793         reassign_track_numbers();
2794 }
2795
2796 void
2797 Session::route_mute_changed (void* /*src*/)
2798 {
2799         set_dirty ();
2800 }
2801
2802 void
2803 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2804 {
2805         boost::shared_ptr<Route> route = wpr.lock();
2806         if (!route) {
2807                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2808                 return;
2809         }
2810
2811         if (route->listening_via_monitor ()) {
2812
2813                 if (Config->get_exclusive_solo()) {
2814                         /* new listen: disable all other listen */
2815                         boost::shared_ptr<RouteList> r = routes.reader ();
2816                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2817                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
2818                                         continue;
2819                                 }
2820                                 (*i)->set_listen (false, this);
2821                         }
2822                 }
2823
2824                 _listen_cnt++;
2825
2826         } else if (_listen_cnt > 0) {
2827
2828                 _listen_cnt--;
2829         }
2830
2831         update_route_solo_state ();
2832 }
2833 void
2834 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2835 {
2836         boost::shared_ptr<Route> route = wpr.lock ();
2837
2838         if (!route) {
2839                 /* should not happen */
2840                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2841                 return;
2842         }
2843
2844         bool send_changed = false;
2845
2846         if (route->solo_isolated()) {
2847                 if (_solo_isolated_cnt == 0) {
2848                         send_changed = true;
2849                 }
2850                 _solo_isolated_cnt++;
2851         } else if (_solo_isolated_cnt > 0) {
2852                 _solo_isolated_cnt--;
2853                 if (_solo_isolated_cnt == 0) {
2854                         send_changed = true;
2855                 }
2856         }
2857
2858         if (send_changed) {
2859                 IsolatedChanged (); /* EMIT SIGNAL */
2860         }
2861 }
2862
2863 void
2864 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2865 {
2866         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2867
2868         if (!self_solo_change) {
2869                 // session doesn't care about changes to soloed-by-others
2870                 return;
2871         }
2872
2873         if (solo_update_disabled) {
2874                 // We know already
2875                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2876                 return;
2877         }
2878
2879         boost::shared_ptr<Route> route = wpr.lock ();
2880         assert (route);
2881
2882         boost::shared_ptr<RouteList> r = routes.reader ();
2883         int32_t delta;
2884
2885         if (route->self_soloed()) {
2886                 delta = 1;
2887         } else {
2888                 delta = -1;
2889         }
2890
2891         RouteGroup* rg = route->route_group ();
2892         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2893
2894         if (delta == 1 && Config->get_exclusive_solo()) {
2895
2896                 /* new solo: disable all other solos, but not the group if its solo-enabled */
2897
2898                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2899                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2900                             (leave_group_alone && ((*i)->route_group() == rg))) {
2901                                 continue;
2902                         }
2903                         (*i)->set_solo (false, this);
2904                 }
2905         }
2906
2907         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2908
2909         solo_update_disabled = true;
2910
2911         RouteList uninvolved;
2912
2913         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2914
2915         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2916                 bool via_sends_only;
2917                 bool in_signal_flow;
2918
2919                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2920                     (leave_group_alone && ((*i)->route_group() == rg))) {
2921                         continue;
2922                 }
2923
2924                 in_signal_flow = false;
2925
2926                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2927
2928                 if ((*i)->feeds (route, &via_sends_only)) {
2929                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2930                         if (!via_sends_only) {
2931                                 if (!route->soloed_by_others_upstream()) {
2932                                         (*i)->mod_solo_by_others_downstream (delta);
2933                                 }
2934                         } else {
2935                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2936                         }
2937                         in_signal_flow = true;
2938                 } else {
2939                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2940                 }
2941
2942                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2943
2944                 if (route->feeds (*i, &via_sends_only)) {
2945                         /* propagate solo upstream only if routing other than
2946                            sends is involved, but do consider the other route
2947                            (*i) to be part of the signal flow even if only
2948                            sends are involved.
2949                         */
2950                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2951                                                                   route->name(),
2952                                                                   (*i)->name(),
2953                                                                   via_sends_only,
2954                                                                   route->soloed_by_others_downstream(),
2955                                                                   route->soloed_by_others_upstream()));
2956                         if (!via_sends_only) {
2957                                 if (!route->soloed_by_others_downstream()) {
2958                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2959                                         (*i)->mod_solo_by_others_upstream (delta);
2960                                 } else {
2961                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2962                                 }
2963                         } else {
2964                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2965                         }
2966                         in_signal_flow = true;
2967                 } else {
2968                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2969                 }
2970
2971                 if (!in_signal_flow) {
2972                         uninvolved.push_back (*i);
2973                 }
2974         }
2975
2976         solo_update_disabled = false;
2977         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2978
2979         update_route_solo_state (r);
2980
2981         /* now notify that the mute state of the routes not involved in the signal
2982            pathway of the just-solo-changed route may have altered.
2983         */
2984
2985         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2986                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2987                 (*i)->mute_changed (this);
2988         }
2989
2990         SoloChanged (); /* EMIT SIGNAL */
2991         set_dirty();
2992 }
2993
2994 void
2995 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2996 {
2997         /* now figure out if anything that matters is soloed (or is "listening")*/
2998
2999         bool something_soloed = false;
3000         uint32_t listeners = 0;
3001         uint32_t isolated = 0;
3002
3003         if (!r) {
3004                 r = routes.reader();
3005         }
3006
3007         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3008                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3009                         something_soloed = true;
3010                 }
3011
3012                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3013                         if (Config->get_solo_control_is_listen_control()) {
3014                                 listeners++;
3015                         } else {
3016                                 (*i)->set_listen (false, this);
3017                         }
3018                 }
3019
3020                 if ((*i)->solo_isolated()) {
3021                         isolated++;
3022                 }
3023         }
3024
3025         if (something_soloed != _non_soloed_outs_muted) {
3026                 _non_soloed_outs_muted = something_soloed;
3027                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3028         }
3029
3030         _listen_cnt = listeners;
3031
3032         if (isolated != _solo_isolated_cnt) {
3033                 _solo_isolated_cnt = isolated;
3034                 IsolatedChanged (); /* EMIT SIGNAL */
3035         }
3036
3037         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3038                                                   something_soloed, listeners, isolated));
3039 }
3040
3041 boost::shared_ptr<RouteList>
3042 Session::get_routes_with_internal_returns() const
3043 {
3044         boost::shared_ptr<RouteList> r = routes.reader ();
3045         boost::shared_ptr<RouteList> rl (new RouteList);
3046
3047         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3048                 if ((*i)->internal_return ()) {
3049                         rl->push_back (*i);
3050                 }
3051         }
3052         return rl;
3053 }
3054
3055 bool
3056 Session::io_name_is_legal (const std::string& name)
3057 {
3058         boost::shared_ptr<RouteList> r = routes.reader ();
3059
3060         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3061                 if ((*i)->name() == name) {
3062                         return false;
3063                 }
3064
3065                 if ((*i)->has_io_processor_named (name)) {
3066                         return false;
3067                 }
3068         }
3069
3070         return true;
3071 }
3072
3073 void
3074 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
3075 {
3076         RouteList rl2;
3077         vector<string> connections;
3078
3079         /* if we are passed only a single route and we're not told to turn
3080          * others off, then just do the simple thing.
3081          */
3082
3083         if (flip_others == false && rl->size() == 1) {
3084                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
3085                 if (mt) {
3086                         mt->set_input_active (onoff);
3087                         return;
3088                 }
3089         }
3090
3091         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
3092
3093                 PortSet& ps ((*rt)->input()->ports());
3094
3095                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
3096                         p->get_connections (connections);
3097                 }
3098
3099                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
3100                         routes_using_input_from (*s, rl2);
3101                 }
3102
3103                 /* scan all relevant routes to see if others are on or off */
3104
3105                 bool others_are_already_on = false;
3106
3107                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3108
3109                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3110
3111                         if (!mt) {
3112                                 continue;
3113                         }
3114
3115                         if ((*r) != (*rt)) {
3116                                 if (mt->input_active()) {
3117                                         others_are_already_on = true;
3118                                 }
3119                         } else {
3120                                 /* this one needs changing */
3121                                 mt->set_input_active (onoff);
3122                         }
3123                 }
3124
3125                 if (flip_others) {
3126
3127                         /* globally reverse other routes */
3128
3129                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3130                                 if ((*r) != (*rt)) {
3131                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3132                                         if (mt) {
3133                                                 mt->set_input_active (!others_are_already_on);
3134                                         }
3135                                 }
3136                         }
3137                 }
3138         }
3139 }
3140
3141 void
3142 Session::routes_using_input_from (const string& str, RouteList& rl)
3143 {
3144         boost::shared_ptr<RouteList> r = routes.reader();
3145
3146         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3147                 if ((*i)->input()->connected_to (str)) {
3148                         rl.push_back (*i);
3149                 }
3150         }
3151 }
3152
3153 boost::shared_ptr<Route>
3154 Session::route_by_name (string name)
3155 {
3156         boost::shared_ptr<RouteList> r = routes.reader ();
3157
3158         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3159                 if ((*i)->name() == name) {
3160                         return *i;
3161                 }
3162         }
3163
3164         return boost::shared_ptr<Route> ((Route*) 0);
3165 }
3166
3167 boost::shared_ptr<Route>
3168 Session::route_by_id (PBD::ID id)
3169 {
3170         boost::shared_ptr<RouteList> r = routes.reader ();
3171
3172         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3173                 if ((*i)->id() == id) {
3174                         return *i;
3175                 }
3176         }
3177
3178         return boost::shared_ptr<Route> ((Route*) 0);
3179 }
3180
3181 boost::shared_ptr<Track>
3182 Session::track_by_diskstream_id (PBD::ID id)
3183 {
3184         boost::shared_ptr<RouteList> r = routes.reader ();
3185
3186         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3187                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3188                 if (t && t->using_diskstream_id (id)) {
3189                         return t;
3190                 }
3191         }
3192
3193         return boost::shared_ptr<Track> ();
3194 }
3195
3196 boost::shared_ptr<Route>
3197 Session::route_by_remote_id (uint32_t id)
3198 {
3199         boost::shared_ptr<RouteList> r = routes.reader ();
3200
3201         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3202                 if ((*i)->remote_control_id() == id) {
3203                         return *i;
3204                 }
3205         }
3206
3207         return boost::shared_ptr<Route> ((Route*) 0);
3208 }
3209
3210
3211 void
3212 Session::reassign_track_numbers ()
3213 {
3214         int64_t tn = 0;
3215         int64_t bn = 0;
3216         RouteList r (*(routes.reader ()));
3217         SignalOrderRouteSorter sorter;
3218         r.sort (sorter);
3219
3220         StateProtector sp (this);
3221
3222         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3223                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3224                         (*i)->set_track_number(++tn);
3225                 }
3226                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
3227                         (*i)->set_track_number(--bn);
3228                 }
3229         }
3230         const uint32_t decimals = ceilf (log10f (tn + 1));
3231         const bool decimals_changed = _track_number_decimals != decimals;
3232         _track_number_decimals = decimals;
3233
3234         if (decimals_changed && config.get_track_name_number ()) {
3235                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3236                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3237                         if (t) {
3238                                 t->resync_track_name();
3239                         }
3240                 }
3241                 // trigger GUI re-layout
3242                 config.ParameterChanged("track-name-number");
3243         }
3244 }
3245
3246 void
3247 Session::playlist_region_added (boost::weak_ptr<Region> w)
3248 {
3249         boost::shared_ptr<Region> r = w.lock ();
3250         if (!r) {
3251                 return;
3252         }
3253
3254         /* These are the operations that are currently in progress... */
3255         list<GQuark> curr = _current_trans_quarks;
3256         curr.sort ();
3257
3258         /* ...and these are the operations during which we want to update
3259            the session range location markers.
3260         */
3261         list<GQuark> ops;
3262         ops.push_back (Operations::capture);
3263         ops.push_back (Operations::paste);
3264         ops.push_back (Operations::duplicate_region);
3265         ops.push_back (Operations::insert_file);
3266         ops.push_back (Operations::insert_region);
3267         ops.push_back (Operations::drag_region_brush);
3268         ops.push_back (Operations::region_drag);
3269         ops.push_back (Operations::selection_grab);
3270         ops.push_back (Operations::region_fill);
3271         ops.push_back (Operations::fill_selection);
3272         ops.push_back (Operations::create_region);
3273         ops.push_back (Operations::region_copy);
3274         ops.push_back (Operations::fixed_time_region_copy);
3275         ops.sort ();
3276
3277         /* See if any of the current operations match the ones that we want */
3278         list<GQuark> in;
3279         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3280
3281         /* If so, update the session range markers */
3282         if (!in.empty ()) {
3283                 maybe_update_session_range (r->position (), r->last_frame ());
3284         }
3285 }
3286
3287 /** Update the session range markers if a is before the current start or
3288  *  b is after the current end.
3289  */
3290 void
3291 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3292 {
3293         if (_state_of_the_state & Loading) {
3294                 return;
3295         }
3296
3297         if (_session_range_location == 0) {
3298
3299                 add_session_range_location (a, b);
3300
3301         } else {
3302
3303                 if (a < _session_range_location->start()) {
3304                         _session_range_location->set_start (a);
3305                 }
3306
3307                 if (b > _session_range_location->end()) {
3308                         _session_range_location->set_end (b);
3309                 }
3310         }
3311 }
3312
3313 void
3314 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3315 {
3316         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3317                 maybe_update_session_range (i->to, i->to + i->length);
3318         }
3319 }
3320
3321 void
3322 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3323 {
3324         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3325                 maybe_update_session_range (i->from, i->to);
3326         }
3327 }
3328
3329 /* Region management */
3330
3331 boost::shared_ptr<Region>
3332 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3333 {
3334         const RegionFactory::RegionMap& regions (RegionFactory::regions());
3335         RegionFactory::RegionMap::const_iterator i;
3336         boost::shared_ptr<Region> region;
3337
3338         Glib::Threads::Mutex::Lock lm (region_lock);
3339
3340         for (i = regions.begin(); i != regions.end(); ++i) {
3341
3342                 region = i->second;
3343
3344                 if (region->whole_file()) {
3345
3346                         if (child->source_equivalent (region)) {
3347                                 return region;
3348                         }
3349                 }
3350         }
3351
3352         return boost::shared_ptr<Region> ();
3353 }
3354
3355 int
3356 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3357 {
3358         set<boost::shared_ptr<Region> > relevant_regions;
3359
3360         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3361                 RegionFactory::get_regions_using_source (*s, relevant_regions);
3362         }
3363
3364         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3365                 set<boost::shared_ptr<Region> >::iterator tmp;
3366
3367                 tmp = r;
3368                 ++tmp;
3369
3370                 playlists->destroy_region (*r);
3371                 RegionFactory::map_remove (*r);
3372
3373                 (*r)->drop_sources ();
3374                 (*r)->drop_references ();
3375
3376                 relevant_regions.erase (r);
3377
3378                 r = tmp;
3379         }
3380
3381         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3382
3383                 {
3384                         Glib::Threads::Mutex::Lock ls (source_lock);
3385                         /* remove from the main source list */
3386                         sources.erase ((*s)->id());
3387                 }
3388
3389                 (*s)->mark_for_remove ();
3390                 (*s)->drop_references ();
3391
3392                 s = srcs.erase (s);
3393         }
3394
3395         return 0;
3396 }
3397
3398 int
3399 Session::remove_last_capture ()
3400 {
3401         list<boost::shared_ptr<Source> > srcs;
3402
3403         boost::shared_ptr<RouteList> rl = routes.reader ();
3404         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3405                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3406                 if (!tr) {
3407                         continue;
3408                 }
3409
3410                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3411
3412                 if (!l.empty()) {
3413                         srcs.insert (srcs.end(), l.begin(), l.end());
3414                         l.clear ();
3415                 }
3416         }
3417
3418         destroy_sources (srcs);
3419
3420         save_state (_current_snapshot_name);
3421
3422         return 0;
3423 }
3424
3425 /* Source Management */
3426
3427 void
3428 Session::add_source (boost::shared_ptr<Source> source)
3429 {
3430         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3431         pair<SourceMap::iterator,bool> result;
3432
3433         entry.first = source->id();
3434         entry.second = source;
3435
3436         {
3437                 Glib::Threads::Mutex::Lock lm (source_lock);
3438                 result = sources.insert (entry);
3439         }
3440
3441         if (result.second) {
3442
3443                 /* yay, new source */
3444
3445                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3446
3447                 if (fs) {
3448                         if (!fs->within_session()) {
3449                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3450                         }
3451                 }
3452
3453                 set_dirty();
3454
3455                 boost::shared_ptr<AudioFileSource> afs;
3456
3457                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3458                         if (Config->get_auto_analyse_audio()) {
3459                                 Analyser::queue_source_for_analysis (source, false);
3460                         }
3461                 }
3462
3463                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3464         }
3465 }
3466
3467 void
3468 Session::remove_source (boost::weak_ptr<Source> src)
3469 {
3470         if (_state_of_the_state & Deletion) {
3471                 return;
3472         }
3473
3474         SourceMap::iterator i;
3475         boost::shared_ptr<Source> source = src.lock();
3476
3477         if (!source) {
3478                 return;
3479         }
3480
3481         {
3482                 Glib::Threads::Mutex::Lock lm (source_lock);
3483
3484                 if ((i = sources.find (source->id())) != sources.end()) {
3485                         sources.erase (i);
3486                 }
3487         }
3488
3489         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
3490
3491                 /* save state so we don't end up with a session file
3492                    referring to non-existent sources.
3493                 */
3494
3495                 save_state (_current_snapshot_name);
3496         }
3497 }
3498
3499 boost::shared_ptr<Source>
3500 Session::source_by_id (const PBD::ID& id)
3501 {
3502         Glib::Threads::Mutex::Lock lm (source_lock);
3503         SourceMap::iterator i;
3504         boost::shared_ptr<Source> source;
3505
3506         if ((i = sources.find (id)) != sources.end()) {
3507                 source = i->second;
3508         }
3509
3510         return source;
3511 }
3512
3513 boost::shared_ptr<AudioFileSource>
3514 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
3515 {
3516         /* Restricted to audio files because only audio sources have channel
3517            as a property.
3518         */
3519
3520         Glib::Threads::Mutex::Lock lm (source_lock);
3521
3522         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
3523                 boost::shared_ptr<AudioFileSource> afs
3524                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3525
3526                 if (afs && afs->path() == path && chn == afs->channel()) {
3527                         return afs;
3528                 }
3529         }
3530
3531         return boost::shared_ptr<AudioFileSource>();
3532 }
3533
3534 boost::shared_ptr<MidiSource>
3535 Session::midi_source_by_path (const std::string& path) const
3536 {
3537         /* Restricted to MIDI files because audio sources require a channel
3538            for unique identification, in addition to a path.
3539         */
3540
3541         Glib::Threads::Mutex::Lock lm (source_lock);
3542
3543         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
3544                 boost::shared_ptr<MidiSource> ms
3545                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
3546                 boost::shared_ptr<FileSource> fs
3547                         = boost::dynamic_pointer_cast<FileSource>(s->second);
3548
3549                 if (ms && fs && fs->path() == path) {
3550                         return ms;
3551                 }
3552         }
3553
3554         return boost::shared_ptr<MidiSource>();
3555 }
3556
3557 uint32_t
3558 Session::count_sources_by_origin (const string& path)
3559 {
3560         uint32_t cnt = 0;
3561         Glib::Threads::Mutex::Lock lm (source_lock);
3562
3563         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3564                 boost::shared_ptr<FileSource> fs
3565                         = boost::dynamic_pointer_cast<FileSource>(i->second);
3566
3567                 if (fs && fs->origin() == path) {
3568                         ++cnt;
3569                 }
3570         }
3571
3572         return cnt;
3573 }
3574
3575 string
3576 Session::peak_path (string base) const
3577 {
3578         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3579 }
3580
3581 string
3582 Session::new_audio_source_path_for_embedded (const std::string& path)
3583 {
3584         /* embedded source:
3585          *
3586          * we know that the filename is already unique because it exists
3587          * out in the filesystem.
3588          *
3589          * However, when we bring it into the session, we could get a
3590          * collision.
3591          *
3592          * Eg. two embedded files:
3593          *
3594          *          /foo/bar/baz.wav
3595          *          /frob/nic/baz.wav
3596          *
3597          * When merged into session, these collide.
3598          *
3599          * There will not be a conflict with in-memory sources
3600          * because when the source was created we already picked
3601          * a unique name for it.
3602          *
3603          * This collision is not likely to be common, but we have to guard
3604          * against it.  So, if there is a collision, take the md5 hash of the
3605          * the path, and use that as the filename instead.
3606          */
3607
3608         SessionDirectory sdir (get_best_session_directory_for_new_audio());
3609         string base = Glib::path_get_basename (path);
3610         string newpath = Glib::build_filename (sdir.sound_path(), base);
3611
3612         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
3613
3614                 MD5 md5;
3615
3616                 md5.digestString (path.c_str());
3617                 md5.writeToString ();
3618                 base = md5.digestChars;
3619
3620                 string ext = get_suffix (path);
3621
3622                 if (!ext.empty()) {
3623                         base += '.';
3624                         base += ext;
3625                 }
3626
3627                 newpath = Glib::build_filename (sdir.sound_path(), base);
3628
3629                 /* if this collides, we're screwed */
3630
3631                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
3632                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
3633                         return string();
3634                 }
3635
3636         }
3637
3638         return newpath;
3639 }
3640
3641 /** Return true if there are no audio file sources that use @param name as
3642  * the filename component of their path.
3643  *
3644  * Return false otherwise.
3645  *
3646  * This method MUST ONLY be used to check in-session, mono files since it
3647  * hard-codes the channel of the audio file source we are looking for as zero.
3648  *
3649  * If/when Ardour supports native files in non-mono formats, the logic here
3650  * will need to be revisited.
3651  */
3652 bool
3653 Session::audio_source_name_is_unique (const string& name)
3654 {
3655         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
3656         vector<space_and_path>::iterator i;
3657         uint32_t existing = 0;
3658
3659         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
3660
3661                 /* note that we search *without* the extension so that
3662                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3663                    in the event that this new name is required for
3664                    a file format change.
3665                 */
3666
3667                 const string spath = *i;
3668
3669                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
3670                         existing++;
3671                         break;
3672                 }
3673
3674                 /* it is possible that we have the path already
3675                  * assigned to a source that has not yet been written
3676                  * (ie. the write source for a diskstream). we have to
3677                  * check this in order to make sure that our candidate
3678                  * path isn't used again, because that can lead to
3679                  * two Sources point to the same file with different
3680                  * notions of their removability.
3681                  */
3682
3683
3684                 string possible_path = Glib::build_filename (spath, name);
3685
3686                 if (audio_source_by_path_and_channel (possible_path, 0)) {
3687                         existing++;
3688                         break;
3689                 }
3690         }
3691
3692         return (existing == 0);
3693 }
3694
3695 string
3696 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)
3697 {
3698         ostringstream sstr;
3699         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3700
3701         if (destructive) {
3702                 sstr << 'T';
3703                 sstr << setfill ('0') << setw (4) << cnt;
3704                 sstr << legalized_base;
3705         } else {
3706                 sstr << legalized_base;
3707
3708                 if (take_required || related_exists) {
3709                         sstr << '-';
3710                         sstr << cnt;
3711                 }
3712         }
3713
3714         if (nchan == 2) {
3715                 if (chan == 0) {
3716                         sstr << "%L";
3717                 } else {
3718                         sstr << "%R";
3719                 }
3720         } else if (nchan > 2) {
3721                 if (nchan < 26) {
3722                         sstr << '%';
3723                         sstr << 'a' + chan;
3724                 } else {
3725                         /* XXX what? more than 26 channels! */
3726                         sstr << '%';
3727                         sstr << chan+1;
3728                 }
3729         }
3730
3731         sstr << ext;
3732
3733         return sstr.str();
3734 }
3735
3736 /** Return a unique name based on \a base for a new internal audio source */
3737 string
3738 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
3739 {
3740         uint32_t cnt;
3741         string possible_name;
3742         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
3743         string legalized;
3744         bool some_related_source_name_exists = false;
3745
3746         legalized = legalize_for_path (base);
3747
3748         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3749
3750         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3751
3752                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
3753
3754                 if (audio_source_name_is_unique (possible_name)) {
3755                         break;
3756                 }
3757
3758                 some_related_source_name_exists = true;
3759
3760                 if (cnt > limit) {
3761                         error << string_compose(
3762                                         _("There are already %1 recordings for %2, which I consider too many."),
3763                                         limit, base) << endmsg;
3764                         destroy ();
3765                         throw failed_constructor();
3766                 }
3767         }
3768
3769         /* We've established that the new name does not exist in any session
3770          * directory, so now find out which one we should use for this new
3771          * audio source.
3772          */
3773
3774         SessionDirectory sdir (get_best_session_directory_for_new_audio());
3775
3776         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
3777
3778         return s;
3779 }
3780
3781 /** Return a unique name based on `base` for a new internal MIDI source */
3782 string
3783 Session::new_midi_source_path (const string& base)
3784 {
3785         uint32_t cnt;
3786         char buf[PATH_MAX+1];
3787         const uint32_t limit = 10000;
3788         string legalized;
3789         string possible_path;
3790         string possible_name;
3791
3792         buf[0] = '\0';
3793         legalized = legalize_for_path (base);
3794
3795         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3796         std::vector<string> sdirs = source_search_path(DataType::MIDI);
3797
3798         /* - the main session folder is the first in the vector.
3799          * - after checking all locations for file-name uniqueness,
3800          *   we keep the one from the last iteration as new file name
3801          * - midi files are small and should just be kept in the main session-folder
3802          *
3803          * -> reverse the array, check main session folder last and use that as location
3804          *    for MIDI files.
3805          */
3806         std::reverse(sdirs.begin(), sdirs.end());
3807
3808         for (cnt = 1; cnt <= limit; ++cnt) {
3809
3810                 vector<space_and_path>::iterator i;
3811                 uint32_t existing = 0;
3812
3813                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
3814
3815                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
3816                         possible_name = buf;
3817
3818                         possible_path = Glib::build_filename (*i, possible_name);
3819
3820                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
3821                                 existing++;
3822                         }
3823
3824                         if (midi_source_by_path (possible_path)) {
3825                                 existing++;
3826                         }
3827                 }
3828
3829                 if (existing == 0) {
3830                         break;
3831                 }
3832
3833                 if (cnt > limit) {
3834                         error << string_compose(
3835                                         _("There are already %1 recordings for %2, which I consider too many."),
3836                                         limit, base) << endmsg;
3837                         destroy ();
3838                         return 0;
3839                 }
3840         }
3841
3842         /* No need to "find best location" for software/app-based RAID, because
3843            MIDI is so small that we always put it in the same place.
3844         */
3845
3846         return possible_path;
3847 }
3848
3849
3850 /** Create a new within-session audio source */
3851 boost::shared_ptr<AudioFileSource>
3852 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
3853 {
3854         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
3855
3856         if (!path.empty()) {
3857                 return boost::dynamic_pointer_cast<AudioFileSource> (
3858                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3859         } else {
3860                 throw failed_constructor ();
3861         }
3862 }
3863
3864 /** Create a new within-session MIDI source */
3865 boost::shared_ptr<MidiSource>
3866 Session::create_midi_source_for_session (string const & basic_name)
3867 {
3868         const string path = new_midi_source_path (basic_name);
3869
3870         if (!path.empty()) {
3871                 return boost::dynamic_pointer_cast<SMFSource> (
3872                         SourceFactory::createWritable (
3873                                 DataType::MIDI, *this, path, false, frame_rate()));
3874         } else {
3875                 throw failed_constructor ();
3876         }
3877 }
3878
3879 /** Create a new within-session MIDI source */
3880 boost::shared_ptr<MidiSource>
3881 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
3882 {
3883         /* the caller passes in the track the source will be used in,
3884            so that we can keep the numbering sane.
3885
3886            Rationale: a track with the name "Foo" that has had N
3887            captures carried out so far will ALREADY have a write source
3888            named "Foo-N+1.mid" waiting to be used for the next capture.
3889
3890            If we call new_midi_source_name() we will get "Foo-N+2". But
3891            there is no region corresponding to "Foo-N+1", so when
3892            "Foo-N+2" appears in the track, the gap presents the user
3893            with odd behaviour - why did it skip past Foo-N+1?
3894
3895            We could explain this to the user in some odd way, but
3896            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
3897            use "Foo-N+1" here.
3898
3899            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
3900         */
3901
3902         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
3903         assert (mt);
3904         std::string name = track->steal_write_source_name ();
3905
3906         if (name.empty()) {
3907                 return boost::shared_ptr<MidiSource>();
3908         }
3909
3910         /* MIDI files are small, just put them in the first location of the
3911            session source search path.
3912         */
3913
3914         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
3915
3916         return boost::dynamic_pointer_cast<SMFSource> (
3917                 SourceFactory::createWritable (
3918                         DataType::MIDI, *this, path, false, frame_rate()));
3919 }
3920
3921
3922 void
3923 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3924 {
3925         if (playlist->hidden()) {
3926                 return;
3927         }
3928
3929         playlists->add (playlist);
3930
3931         if (unused) {
3932                 playlist->release();
3933         }
3934
3935         set_dirty();
3936 }
3937
3938 void
3939 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3940 {
3941         if (_state_of_the_state & Deletion) {
3942                 return;
3943         }
3944
3945         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3946
3947         if (!playlist) {
3948                 return;
3949         }
3950
3951         playlists->remove (playlist);
3952
3953         set_dirty();
3954 }
3955
3956 void
3957 Session::set_audition (boost::shared_ptr<Region> r)
3958 {
3959         pending_audition_region = r;
3960         add_post_transport_work (PostTransportAudition);
3961         _butler->schedule_transport_work ();
3962 }
3963
3964 void
3965 Session::audition_playlist ()
3966 {
3967         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3968         ev->region.reset ();
3969         queue_event (ev);
3970 }
3971
3972 void
3973 Session::non_realtime_set_audition ()
3974 {
3975         assert (pending_audition_region);
3976         auditioner->audition_region (pending_audition_region);
3977         pending_audition_region.reset ();
3978         AuditionActive (true); /* EMIT SIGNAL */
3979 }
3980
3981 void
3982 Session::audition_region (boost::shared_ptr<Region> r)
3983 {
3984         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3985         ev->region = r;
3986         queue_event (ev);
3987 }
3988
3989 void
3990 Session::cancel_audition ()
3991 {
3992         if (!auditioner) {
3993                 return;
3994         }
3995         if (auditioner->auditioning()) {
3996                 auditioner->cancel_audition ();
3997                 AuditionActive (false); /* EMIT SIGNAL */
3998         }
3999 }
4000
4001 bool
4002 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4003 {
4004         if (a->is_monitor()) {
4005                 return true;
4006         }
4007         if (b->is_monitor()) {
4008                 return false;
4009         }
4010         return a->order_key () < b->order_key ();
4011 }
4012
4013 bool
4014 Session::is_auditioning () const
4015 {
4016         /* can be called before we have an auditioner object */
4017         if (auditioner) {
4018                 return auditioner->auditioning();
4019         } else {
4020                 return false;
4021         }
4022 }
4023
4024 void
4025 Session::graph_reordered ()
4026 {
4027         /* don't do this stuff if we are setting up connections
4028            from a set_state() call or creating new tracks. Ditto for deletion.
4029         */
4030
4031         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4032                 return;
4033         }
4034
4035         /* every track/bus asked for this to be handled but it was deferred because
4036            we were connecting. do it now.
4037         */
4038
4039         request_input_change_handling ();
4040
4041         resort_routes ();
4042
4043         /* force all diskstreams to update their capture offset values to
4044            reflect any changes in latencies within the graph.
4045         */
4046
4047         boost::shared_ptr<RouteList> rl = routes.reader ();
4048         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4049                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4050                 if (tr) {
4051                         tr->set_capture_offset ();
4052                 }
4053         }
4054 }
4055
4056 /** @return Number of frames that there is disk space available to write,
4057  *  if known.
4058  */
4059 boost::optional<framecnt_t>
4060 Session::available_capture_duration ()
4061 {
4062         Glib::Threads::Mutex::Lock lm (space_lock);
4063
4064         if (_total_free_4k_blocks_uncertain) {
4065                 return boost::optional<framecnt_t> ();
4066         }
4067
4068         float sample_bytes_on_disk = 4.0; // keep gcc happy
4069
4070         switch (config.get_native_file_data_format()) {
4071         case FormatFloat:
4072                 sample_bytes_on_disk = 4.0;
4073                 break;
4074
4075         case FormatInt24:
4076                 sample_bytes_on_disk = 3.0;
4077                 break;
4078
4079         case FormatInt16:
4080                 sample_bytes_on_disk = 2.0;
4081                 break;
4082
4083         default:
4084                 /* impossible, but keep some gcc versions happy */
4085                 fatal << string_compose (_("programming error: %1"),
4086                                          X_("illegal native file data format"))
4087                       << endmsg;
4088                 abort(); /*NOTREACHED*/
4089         }
4090
4091         double scale = 4096.0 / sample_bytes_on_disk;
4092
4093         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4094                 return max_framecnt;
4095         }
4096
4097         return (framecnt_t) floor (_total_free_4k_blocks * scale);
4098 }
4099
4100 void
4101 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
4102 {
4103         {
4104                 RCUWriter<BundleList> writer (_bundles);
4105                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4106                 b->push_back (bundle);
4107         }
4108
4109         BundleAdded (bundle); /* EMIT SIGNAL */
4110
4111         set_dirty();
4112 }
4113
4114 void
4115 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
4116 {
4117         bool removed = false;
4118
4119         {
4120                 RCUWriter<BundleList> writer (_bundles);
4121                 boost::shared_ptr<BundleList> b = writer.get_copy ();
4122                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
4123
4124                 if (i != b->end()) {
4125                         b->erase (i);
4126                         removed = true;
4127                 }
4128         }
4129
4130         if (removed) {
4131                  BundleRemoved (bundle); /* EMIT SIGNAL */
4132         }
4133
4134         set_dirty();
4135 }
4136
4137 boost::shared_ptr<Bundle>
4138 Session::bundle_by_name (string name) const
4139 {
4140         boost::shared_ptr<BundleList> b = _bundles.reader ();
4141
4142         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
4143                 if ((*i)->name() == name) {
4144                         return* i;
4145                 }
4146         }
4147
4148         return boost::shared_ptr<Bundle> ();
4149 }
4150
4151 void
4152 Session::tempo_map_changed (const PropertyChange&)
4153 {
4154         clear_clicks ();
4155
4156         playlists->update_after_tempo_map_change ();
4157
4158         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4159
4160         set_dirty ();
4161 }
4162
4163 void
4164 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
4165 {
4166         for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
4167                 (*i)->recompute_frames_from_bbt ();
4168         }
4169 }
4170
4171 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4172  * the given count with the current block size.
4173  */
4174 void
4175 Session::ensure_buffers (ChanCount howmany)
4176 {
4177         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4178 }
4179
4180 void
4181 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4182 {
4183         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4184                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4185         }
4186 }
4187
4188 uint32_t
4189 Session::next_insert_id ()
4190 {
4191         /* this doesn't really loop forever. just think about it */
4192
4193         while (true) {
4194                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4195                         if (!insert_bitset[n]) {
4196                                 insert_bitset[n] = true;
4197                                 return n;
4198
4199                         }
4200                 }
4201
4202                 /* none available, so resize and try again */
4203
4204                 insert_bitset.resize (insert_bitset.size() + 16, false);
4205         }
4206 }
4207
4208 uint32_t
4209 Session::next_send_id ()
4210 {
4211         /* this doesn't really loop forever. just think about it */
4212
4213         while (true) {
4214                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4215                         if (!send_bitset[n]) {
4216                                 send_bitset[n] = true;
4217                                 return n;
4218
4219                         }
4220                 }
4221
4222                 /* none available, so resize and try again */
4223
4224                 send_bitset.resize (send_bitset.size() + 16, false);
4225         }
4226 }
4227
4228 uint32_t
4229 Session::next_aux_send_id ()
4230 {
4231         /* this doesn't really loop forever. just think about it */
4232
4233         while (true) {
4234                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4235                         if (!aux_send_bitset[n]) {
4236                                 aux_send_bitset[n] = true;
4237                                 return n;
4238
4239                         }
4240                 }
4241
4242                 /* none available, so resize and try again */
4243
4244                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4245         }
4246 }
4247
4248 uint32_t
4249 Session::next_return_id ()
4250 {
4251         /* this doesn't really loop forever. just think about it */
4252
4253         while (true) {
4254                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
4255                         if (!return_bitset[n]) {
4256                                 return_bitset[n] = true;
4257                                 return n;
4258
4259                         }
4260                 }
4261
4262                 /* none available, so resize and try again */
4263
4264                 return_bitset.resize (return_bitset.size() + 16, false);
4265         }
4266 }
4267
4268 void
4269 Session::mark_send_id (uint32_t id)
4270 {
4271         if (id >= send_bitset.size()) {
4272                 send_bitset.resize (id+16, false);
4273         }
4274         if (send_bitset[id]) {
4275                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4276         }
4277         send_bitset[id] = true;
4278 }
4279
4280 void
4281 Session::mark_aux_send_id (uint32_t id)
4282 {
4283         if (id >= aux_send_bitset.size()) {
4284                 aux_send_bitset.resize (id+16, false);
4285         }
4286         if (aux_send_bitset[id]) {
4287                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4288         }
4289         aux_send_bitset[id] = true;
4290 }
4291
4292 void
4293 Session::mark_return_id (uint32_t id)
4294 {
4295         if (id >= return_bitset.size()) {
4296                 return_bitset.resize (id+16, false);
4297         }
4298         if (return_bitset[id]) {
4299                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4300         }
4301         return_bitset[id] = true;
4302 }
4303
4304 void
4305 Session::mark_insert_id (uint32_t id)
4306 {
4307         if (id >= insert_bitset.size()) {
4308                 insert_bitset.resize (id+16, false);
4309         }
4310         if (insert_bitset[id]) {
4311                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4312         }
4313         insert_bitset[id] = true;
4314 }
4315
4316 void
4317 Session::unmark_send_id (uint32_t id)
4318 {
4319         if (id < send_bitset.size()) {
4320                 send_bitset[id] = false;
4321         }
4322 }
4323
4324 void
4325 Session::unmark_aux_send_id (uint32_t id)
4326 {
4327         if (id < aux_send_bitset.size()) {
4328                 aux_send_bitset[id] = false;
4329         }
4330 }
4331
4332 void
4333 Session::unmark_return_id (uint32_t id)
4334 {
4335         if (id < return_bitset.size()) {
4336                 return_bitset[id] = false;
4337         }
4338 }
4339
4340 void
4341 Session::unmark_insert_id (uint32_t id)
4342 {
4343         if (id < insert_bitset.size()) {
4344                 insert_bitset[id] = false;
4345         }
4346 }
4347
4348 void
4349 Session::reset_native_file_format ()
4350 {
4351         boost::shared_ptr<RouteList> rl = routes.reader ();
4352         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4353                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4354                 if (tr) {
4355                         /* don't save state as we do this, there's no point
4356                          */
4357
4358                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4359                         tr->reset_write_sources (false);
4360                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4361                 }
4362         }
4363 }
4364
4365 bool
4366 Session::route_name_unique (string n) const
4367 {
4368         boost::shared_ptr<RouteList> r = routes.reader ();
4369
4370         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4371                 if ((*i)->name() == n) {
4372                         return false;
4373                 }
4374         }
4375
4376         return true;
4377 }
4378
4379 bool
4380 Session::route_name_internal (string n) const
4381 {
4382         if (auditioner && auditioner->name() == n) {
4383                 return true;
4384         }
4385
4386         if (_click_io && _click_io->name() == n) {
4387                 return true;
4388         }
4389
4390         return false;
4391 }
4392
4393 int
4394 Session::freeze_all (InterThreadInfo& itt)
4395 {
4396         boost::shared_ptr<RouteList> r = routes.reader ();
4397
4398         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4399
4400                 boost::shared_ptr<Track> t;
4401
4402                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4403                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
4404                            of every track.
4405                         */
4406                         t->freeze_me (itt);
4407                 }
4408         }
4409
4410         return 0;
4411 }
4412
4413 boost::shared_ptr<Region>
4414 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
4415                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4416                           InterThreadInfo& itt,
4417                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4418                           bool for_export, bool for_freeze)
4419 {
4420         boost::shared_ptr<Region> result;
4421         boost::shared_ptr<Playlist> playlist;
4422         boost::shared_ptr<Source> source;
4423         ChanCount diskstream_channels (track.n_channels());
4424         framepos_t position;
4425         framecnt_t this_chunk;
4426         framepos_t to_do;
4427         framepos_t latency_skip;
4428         BufferSet buffers;
4429         framepos_t len = end - start;
4430         bool need_block_size_reset = false;
4431         ChanCount const max_proc = track.max_processor_streams ();
4432         string legal_playlist_name;
4433         string possible_path;
4434
4435         if (end <= start) {
4436                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4437                                          end, start) << endmsg;
4438                 return result;
4439         }
4440
4441         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
4442                         include_endpoint, for_export, for_freeze);
4443
4444         if (diskstream_channels.n(track.data_type()) < 1) {
4445                 error << _("Cannot write a range with no data.") << endmsg;
4446                 return result;
4447         }
4448
4449         // block all process callback handling
4450
4451         block_processing ();
4452
4453         {
4454                 // synchronize with AudioEngine::process_callback()
4455                 // make sure processing is not currently running
4456                 // and processing_blocked() is honored before
4457                 // acquiring thread buffers
4458                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4459         }
4460
4461         _bounce_processing_active = true;
4462
4463         /* call tree *MUST* hold route_lock */
4464
4465         if ((playlist = track.playlist()) == 0) {
4466                 goto out;
4467         }
4468
4469         legal_playlist_name = legalize_for_path (playlist->name());
4470
4471         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
4472
4473                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
4474                 string path = ((track.data_type() == DataType::AUDIO)
4475                                ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
4476                                : new_midi_source_path (legal_playlist_name));
4477
4478                 if (path.empty()) {
4479                         goto out;
4480                 }
4481
4482                 try {
4483                         source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
4484                 }
4485
4486                 catch (failed_constructor& err) {
4487                         error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
4488                         goto out;
4489                 }
4490
4491                 srcs.push_back (source);
4492         }
4493
4494         /* tell redirects that care that we are about to use a much larger
4495          * blocksize. this will flush all plugins too, so that they are ready
4496          * to be used for this process.
4497          */
4498
4499         need_block_size_reset = true;
4500         track.set_block_size (bounce_chunk_size);
4501         _engine.main_thread()->get_buffers ();
4502
4503         position = start;
4504         to_do = len;
4505         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4506
4507         /* create a set of reasonably-sized buffers */
4508         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4509                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
4510         }
4511         buffers.set_count (max_proc);
4512
4513         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4514                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4515                 boost::shared_ptr<MidiSource> ms;
4516                 if (afs) {
4517                         afs->prepare_for_peakfile_writes ();
4518                 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
4519                         Source::Lock lock(ms->mutex());
4520                         ms->mark_streaming_write_started(lock);
4521                 }
4522         }
4523
4524         while (to_do && !itt.cancel) {
4525
4526                 this_chunk = min (to_do, bounce_chunk_size);
4527
4528                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
4529                         goto out;
4530                 }
4531
4532                 start += this_chunk;
4533                 to_do -= this_chunk;
4534                 itt.progress = (float) (1.0 - ((double) to_do / len));
4535
4536                 if (latency_skip >= bounce_chunk_size) {
4537                         latency_skip -= bounce_chunk_size;
4538                         continue;
4539                 }
4540
4541                 const framecnt_t current_chunk = this_chunk - latency_skip;
4542
4543                 uint32_t n = 0;
4544                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4545                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4546                         boost::shared_ptr<MidiSource> ms;
4547
4548                         if (afs) {
4549                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
4550                                         goto out;
4551                                 }
4552                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
4553                                 Source::Lock lock(ms->mutex());
4554
4555                                 const MidiBuffer& buf = buffers.get_midi(0);
4556                                 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
4557                                         Evoral::Event<framepos_t> ev = *i;
4558                                         ev.set_time(ev.time() - position);
4559                                         ms->append_event_frames(lock, ev, ms->timeline_position());
4560                                 }
4561                         }
4562                 }
4563                 latency_skip = 0;
4564         }
4565
4566         /* post-roll, pick up delayed processor output */
4567         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4568
4569         while (latency_skip && !itt.cancel) {
4570                 this_chunk = min (latency_skip, bounce_chunk_size);
4571                 latency_skip -= this_chunk;
4572
4573                 buffers.silence (this_chunk, 0);
4574                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
4575
4576                 uint32_t n = 0;
4577                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4578                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4579
4580                         if (afs) {
4581                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4582                                         goto out;
4583                                 }
4584                         }
4585                 }
4586         }
4587
4588         if (!itt.cancel) {
4589
4590                 time_t now;
4591                 struct tm* xnow;
4592                 time (&now);
4593                 xnow = localtime (&now);
4594
4595                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4596                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4597                         boost::shared_ptr<MidiSource> ms;
4598
4599                         if (afs) {
4600                                 afs->update_header (position, *xnow, now);
4601                                 afs->flush_header ();
4602                         } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
4603                                 Source::Lock lock(ms->mutex());
4604                                 ms->mark_streaming_write_completed(lock);
4605                         }
4606                 }
4607
4608                 /* construct a region to represent the bounced material */
4609
4610                 PropertyList plist;
4611
4612                 plist.add (Properties::start, 0);
4613                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4614                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4615
4616                 result = RegionFactory::create (srcs, plist);
4617
4618         }
4619
4620   out:
4621         if (!result) {
4622                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4623                         (*src)->mark_for_remove ();
4624                         (*src)->drop_references ();
4625                 }
4626
4627         } else {
4628                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4629                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4630
4631                         if (afs)
4632                                 afs->done_with_peakfile_writes ();
4633                 }
4634         }
4635
4636         _bounce_processing_active = false;
4637
4638         if (need_block_size_reset) {
4639                 _engine.main_thread()->drop_buffers ();
4640                 track.set_block_size (get_block_size());
4641         }
4642
4643         unblock_processing ();
4644
4645         return result;
4646 }
4647
4648 gain_t*
4649 Session::gain_automation_buffer() const
4650 {
4651         return ProcessThread::gain_automation_buffer ();
4652 }
4653
4654 gain_t*
4655 Session::send_gain_automation_buffer() const
4656 {
4657         return ProcessThread::send_gain_automation_buffer ();
4658 }
4659
4660 pan_t**
4661 Session::pan_automation_buffer() const
4662 {
4663         return ProcessThread::pan_automation_buffer ();
4664 }
4665
4666 BufferSet&
4667 Session::get_silent_buffers (ChanCount count)
4668 {
4669         return ProcessThread::get_silent_buffers (count);
4670 }
4671
4672 BufferSet&
4673 Session::get_scratch_buffers (ChanCount count, bool silence)
4674 {
4675         return ProcessThread::get_scratch_buffers (count, silence);
4676 }
4677
4678 BufferSet&
4679 Session::get_route_buffers (ChanCount count, bool silence)
4680 {
4681         return ProcessThread::get_route_buffers (count, silence);
4682 }
4683
4684
4685 BufferSet&
4686 Session::get_mix_buffers (ChanCount count)
4687 {
4688         return ProcessThread::get_mix_buffers (count);
4689 }
4690
4691 uint32_t
4692 Session::ntracks () const
4693 {
4694         uint32_t n = 0;
4695         boost::shared_ptr<RouteList> r = routes.reader ();
4696
4697         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4698                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4699                         ++n;
4700                 }
4701         }
4702
4703         return n;
4704 }
4705
4706 uint32_t
4707 Session::nbusses () const
4708 {
4709         uint32_t n = 0;
4710         boost::shared_ptr<RouteList> r = routes.reader ();
4711
4712         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4713                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4714                         ++n;
4715                 }
4716         }
4717
4718         return n;
4719 }
4720
4721 void
4722 Session::add_automation_list(AutomationList *al)
4723 {
4724         automation_lists[al->id()] = al;
4725 }
4726
4727 /** @return true if there is at least one record-enabled track, otherwise false */
4728 bool
4729 Session::have_rec_enabled_track () const
4730 {
4731         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4732 }
4733
4734 /** Update the state of our rec-enabled tracks flag */
4735 void
4736 Session::update_have_rec_enabled_track ()
4737 {
4738         boost::shared_ptr<RouteList> rl = routes.reader ();
4739         RouteList::iterator i = rl->begin();
4740         while (i != rl->end ()) {
4741
4742                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4743                 if (tr && tr->record_enabled ()) {
4744                         break;
4745                 }
4746
4747                 ++i;
4748         }
4749
4750         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4751
4752         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4753
4754         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4755                 RecordStateChanged (); /* EMIT SIGNAL */
4756         }
4757 }
4758
4759 void
4760 Session::listen_position_changed ()
4761 {
4762         boost::shared_ptr<RouteList> r = routes.reader ();
4763
4764         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4765                 (*i)->listen_position_changed ();
4766         }
4767 }
4768
4769 void
4770 Session::solo_control_mode_changed ()
4771 {
4772         /* cancel all solo or all listen when solo control mode changes */
4773
4774         if (soloing()) {
4775                 set_solo (get_routes(), false);
4776         } else if (listening()) {
4777                 set_listen (get_routes(), false);
4778         }
4779 }
4780
4781 /** Called when a property of one of our route groups changes */
4782 void
4783 Session::route_group_property_changed (RouteGroup* rg)
4784 {
4785         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4786 }
4787
4788 /** Called when a route is added to one of our route groups */
4789 void
4790 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4791 {
4792         RouteAddedToRouteGroup (rg, r);
4793 }
4794
4795 /** Called when a route is removed from one of our route groups */
4796 void
4797 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4798 {
4799         RouteRemovedFromRouteGroup (rg, r);
4800 }
4801
4802 boost::shared_ptr<RouteList>
4803 Session::get_tracks () const
4804 {
4805         boost::shared_ptr<RouteList> rl = routes.reader ();
4806         boost::shared_ptr<RouteList> tl (new RouteList);
4807
4808         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
4809                 if (boost::dynamic_pointer_cast<Track> (*r)) {
4810                         if (!(*r)->is_auditioner()) {
4811                                 tl->push_back (*r);
4812                         }
4813                 }
4814         }
4815         return tl;
4816 }
4817
4818 boost::shared_ptr<RouteList>
4819 Session::get_routes_with_regions_at (framepos_t const p) const
4820 {
4821         boost::shared_ptr<RouteList> r = routes.reader ();
4822         boost::shared_ptr<RouteList> rl (new RouteList);
4823
4824         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4825                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4826                 if (!tr) {
4827                         continue;
4828                 }
4829
4830                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4831                 if (!pl) {
4832                         continue;
4833                 }
4834
4835                 if (pl->has_region_at (p)) {
4836                         rl->push_back (*i);
4837                 }
4838         }
4839
4840         return rl;
4841 }
4842
4843 void
4844 Session::goto_end ()
4845 {
4846         if (_session_range_location) {
4847                 request_locate (_session_range_location->end(), false);
4848         } else {
4849                 request_locate (0, false);
4850         }
4851 }
4852
4853 void
4854 Session::goto_start ()
4855 {
4856         if (_session_range_location) {
4857                 request_locate (_session_range_location->start(), false);
4858         } else {
4859                 request_locate (0, false);
4860         }
4861 }
4862
4863 framepos_t
4864 Session::current_start_frame () const
4865 {
4866         return _session_range_location ? _session_range_location->start() : 0;
4867 }
4868
4869 framepos_t
4870 Session::current_end_frame () const
4871 {
4872         return _session_range_location ? _session_range_location->end() : 0;
4873 }
4874
4875 void
4876 Session::add_session_range_location (framepos_t start, framepos_t end)
4877 {
4878         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4879         _locations->add (_session_range_location);
4880 }
4881
4882 void
4883 Session::step_edit_status_change (bool yn)
4884 {
4885         bool send = false;
4886
4887         bool val = false;
4888         if (yn) {
4889                 send = (_step_editors == 0);
4890                 val = true;
4891
4892                 _step_editors++;
4893         } else {
4894                 send = (_step_editors == 1);
4895                 val = false;
4896
4897                 if (_step_editors > 0) {
4898                         _step_editors--;
4899                 }
4900         }
4901
4902         if (send) {
4903                 StepEditStatusChange (val);
4904         }
4905 }
4906
4907
4908 void
4909 Session::start_time_changed (framepos_t old)
4910 {
4911         /* Update the auto loop range to match the session range
4912            (unless the auto loop range has been changed by the user)
4913         */
4914
4915         Location* s = _locations->session_range_location ();
4916         if (s == 0) {
4917                 return;
4918         }
4919
4920         Location* l = _locations->auto_loop_location ();
4921
4922         if (l && l->start() == old) {
4923                 l->set_start (s->start(), true);
4924         }
4925 }
4926
4927 void
4928 Session::end_time_changed (framepos_t old)
4929 {
4930         /* Update the auto loop range to match the session range
4931            (unless the auto loop range has been changed by the user)
4932         */
4933
4934         Location* s = _locations->session_range_location ();
4935         if (s == 0) {
4936                 return;
4937         }
4938
4939         Location* l = _locations->auto_loop_location ();
4940
4941         if (l && l->end() == old) {
4942                 l->set_end (s->end(), true);
4943         }
4944 }
4945
4946 std::vector<std::string>
4947 Session::source_search_path (DataType type) const
4948 {
4949         Searchpath sp;
4950
4951         if (session_dirs.size() == 1) {
4952                 switch (type) {
4953                 case DataType::AUDIO:
4954                         sp.push_back (_session_dir->sound_path());
4955                         break;
4956                 case DataType::MIDI:
4957                         sp.push_back (_session_dir->midi_path());
4958                         break;
4959                 }
4960         } else {
4961                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4962                         SessionDirectory sdir (i->path);
4963                         switch (type) {
4964                         case DataType::AUDIO:
4965                                 sp.push_back (sdir.sound_path());
4966                                 break;
4967                         case DataType::MIDI:
4968                                 sp.push_back (sdir.midi_path());
4969                                 break;
4970                         }
4971                 }
4972         }
4973
4974         if (type == DataType::AUDIO) {
4975                 const string sound_path_2X = _session_dir->sound_path_2X();
4976                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4977                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
4978                                 sp.push_back (sound_path_2X);
4979                         }
4980                 }
4981         }
4982
4983         // now check the explicit (possibly user-specified) search path
4984
4985         switch (type) {
4986         case DataType::AUDIO:
4987                 sp += Searchpath(config.get_audio_search_path ());
4988                 break;
4989         case DataType::MIDI:
4990                 sp += Searchpath(config.get_midi_search_path ());
4991                 break;
4992         }
4993
4994         return sp;
4995 }
4996
4997 void
4998 Session::ensure_search_path_includes (const string& path, DataType type)
4999 {
5000         Searchpath sp;
5001
5002         if (path == ".") {
5003                 return;
5004         }
5005
5006         switch (type) {
5007         case DataType::AUDIO:
5008                 sp += Searchpath(config.get_audio_search_path ());
5009                 break;
5010         case DataType::MIDI:
5011                 sp += Searchpath (config.get_midi_search_path ());
5012                 break;
5013         }
5014
5015         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5016                 /* No need to add this new directory if it has the same inode as
5017                    an existing one; checking inode rather than name prevents duplicated
5018                    directories when we are using symlinks.
5019
5020                    On Windows, I think we could just do if (*i == path) here.
5021                 */
5022                 if (PBD::equivalent_paths (*i, path)) {
5023                         return;
5024                 }
5025         }
5026
5027         sp += path;
5028
5029         switch (type) {
5030         case DataType::AUDIO:
5031                 config.set_audio_search_path (sp.to_string());
5032                 break;
5033         case DataType::MIDI:
5034                 config.set_midi_search_path (sp.to_string());
5035                 break;
5036         }
5037 }
5038
5039 void
5040 Session::remove_dir_from_search_path (const string& dir, DataType type)
5041 {
5042         Searchpath sp;
5043
5044         switch (type) {
5045         case DataType::AUDIO:
5046                 sp = Searchpath(config.get_audio_search_path ());
5047                 break;
5048         case DataType::MIDI:
5049                 sp = Searchpath (config.get_midi_search_path ());
5050                 break;
5051         }
5052
5053         sp -= dir;
5054
5055         switch (type) {
5056         case DataType::AUDIO:
5057                 config.set_audio_search_path (sp.to_string());
5058                 break;
5059         case DataType::MIDI:
5060                 config.set_midi_search_path (sp.to_string());
5061                 break;
5062         }
5063
5064 }
5065
5066 boost::shared_ptr<Speakers>
5067 Session::get_speakers()
5068 {
5069         return _speakers;
5070 }
5071
5072 list<string>
5073 Session::unknown_processors () const
5074 {
5075         list<string> p;
5076
5077         boost::shared_ptr<RouteList> r = routes.reader ();
5078         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5079                 list<string> t = (*i)->unknown_processors ();
5080                 copy (t.begin(), t.end(), back_inserter (p));
5081         }
5082
5083         p.sort ();
5084         p.unique ();
5085
5086         return p;
5087 }
5088
5089 void
5090 Session::update_latency (bool playback)
5091 {
5092         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
5093
5094         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
5095                 return;
5096         }
5097
5098         boost::shared_ptr<RouteList> r = routes.reader ();
5099         framecnt_t max_latency = 0;
5100
5101         if (playback) {
5102                 /* reverse the list so that we work backwards from the last route to run to the first */
5103                 RouteList* rl = routes.reader().get();
5104                 r.reset (new RouteList (*rl));
5105                 reverse (r->begin(), r->end());
5106         }
5107
5108         /* compute actual latency values for the given direction and store them all in per-port
5109            structures. this will also publish the same values (to JACK) so that computation of latency
5110            for routes can consistently use public latency values.
5111         */
5112
5113         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5114                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
5115         }
5116
5117         /* because we latency compensate playback, our published playback latencies should
5118            be the same for all output ports - all material played back by ardour has
5119            the same latency, whether its caused by plugins or by latency compensation. since
5120            these may differ from the values computed above, reset all playback port latencies
5121            to the same value.
5122         */
5123
5124         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
5125
5126         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5127                 (*i)->set_public_port_latencies (max_latency, playback);
5128         }
5129
5130         if (playback) {
5131
5132                 post_playback_latency ();
5133
5134         } else {
5135
5136                 post_capture_latency ();
5137         }
5138
5139         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
5140 }
5141
5142 void
5143 Session::post_playback_latency ()
5144 {
5145         set_worst_playback_latency ();
5146
5147         boost::shared_ptr<RouteList> r = routes.reader ();
5148
5149         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5150                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5151                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
5152                 }
5153         }
5154
5155         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5156                 (*i)->set_latency_compensation (_worst_track_latency);
5157         }
5158 }
5159
5160 void
5161 Session::post_capture_latency ()
5162 {
5163         set_worst_capture_latency ();
5164
5165         /* reflect any changes in capture latencies into capture offsets
5166          */
5167
5168         boost::shared_ptr<RouteList> rl = routes.reader();
5169         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5170                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5171                 if (tr) {
5172                         tr->set_capture_offset ();
5173                 }
5174         }
5175 }
5176
5177 void
5178 Session::initialize_latencies ()
5179 {
5180         {
5181                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5182                 update_latency (false);
5183                 update_latency (true);
5184         }
5185
5186         set_worst_io_latencies ();
5187 }
5188
5189 void
5190 Session::set_worst_io_latencies ()
5191 {
5192         set_worst_playback_latency ();
5193         set_worst_capture_latency ();
5194 }
5195
5196 void
5197 Session::set_worst_playback_latency ()
5198 {
5199         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5200                 return;
5201         }
5202
5203         _worst_output_latency = 0;
5204
5205         if (!_engine.connected()) {
5206                 return;
5207         }
5208
5209         boost::shared_ptr<RouteList> r = routes.reader ();
5210
5211         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5212                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5213         }
5214
5215         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5216 }
5217
5218 void
5219 Session::set_worst_capture_latency ()
5220 {
5221         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5222                 return;
5223         }
5224
5225         _worst_input_latency = 0;
5226
5227         if (!_engine.connected()) {
5228                 return;
5229         }
5230
5231         boost::shared_ptr<RouteList> r = routes.reader ();
5232
5233         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5234                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
5235         }
5236
5237         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
5238 }
5239
5240 void
5241 Session::update_latency_compensation (bool force_whole_graph)
5242 {
5243         bool some_track_latency_changed = false;
5244
5245         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5246                 return;
5247         }
5248
5249         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
5250
5251         _worst_track_latency = 0;
5252
5253         boost::shared_ptr<RouteList> r = routes.reader ();
5254
5255         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5256                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5257                         framecnt_t tl;
5258                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
5259                                 some_track_latency_changed = true;
5260                         }
5261                         _worst_track_latency = max (tl, _worst_track_latency);
5262                 }
5263         }
5264
5265         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
5266                                                      (some_track_latency_changed ? "yes" : "no")));
5267
5268         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
5269
5270         if (some_track_latency_changed || force_whole_graph)  {
5271                 _engine.update_latencies ();
5272         }
5273
5274
5275         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5276                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5277                 if (!tr) {
5278                         continue;
5279                 }
5280                 tr->set_capture_offset ();
5281         }
5282 }
5283
5284 char
5285 Session::session_name_is_legal (const string& path)
5286 {
5287         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
5288
5289         for (int i = 0; illegal_chars[i]; ++i) {
5290                 if (path.find (illegal_chars[i]) != string::npos) {
5291                         return illegal_chars[i];
5292                 }
5293         }
5294
5295         return 0;
5296 }
5297
5298 uint32_t
5299 Session::next_control_id () const
5300 {
5301         int subtract = 0;
5302
5303         /* the monitor bus remote ID is in a different
5304          * "namespace" than regular routes. its existence doesn't
5305          * affect normal (low) numbered routes.
5306          */
5307
5308         if (_monitor_out) {
5309                 subtract++;
5310         }
5311
5312         return nroutes() - subtract;
5313 }
5314
5315 void
5316 Session::notify_remote_id_change ()
5317 {
5318         if (deletion_in_progress()) {
5319                 return;
5320         }
5321
5322         switch (Config->get_remote_model()) {
5323         case MixerOrdered:
5324                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
5325                 break;
5326         default:
5327                 break;
5328         }
5329 }
5330
5331 void
5332 Session::sync_order_keys ()
5333 {
5334         if (deletion_in_progress()) {
5335                 return;
5336         }
5337
5338         /* tell everyone that something has happened to the sort keys
5339            and let them sync up with the change(s)
5340            this will give objects that manage the sort order keys the
5341            opportunity to keep them in sync if they wish to.
5342         */
5343
5344         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
5345
5346         reassign_track_numbers();
5347
5348         Route::SyncOrderKeys (); /* EMIT SIGNAL */
5349
5350         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
5351 }
5352
5353 bool
5354 Session::operation_in_progress (GQuark op) const
5355 {
5356         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
5357 }
5358
5359 boost::shared_ptr<Port>
5360 Session::ltc_input_port () const
5361 {
5362         return _ltc_input->nth (0);
5363 }
5364
5365 boost::shared_ptr<Port>
5366 Session::ltc_output_port () const
5367 {
5368         return _ltc_output->nth (0);
5369 }
5370
5371 void
5372 Session::reconnect_ltc_input ()
5373 {
5374         if (_ltc_input) {
5375
5376                 string src = Config->get_ltc_source_port();
5377
5378                 _ltc_input->disconnect (this);
5379
5380                 if (src != _("None") && !src.empty())  {
5381                         _ltc_input->nth (0)->connect (src);
5382                 }
5383         }
5384 }
5385
5386 void
5387 Session::reconnect_ltc_output ()
5388 {
5389         if (_ltc_output) {
5390
5391 #if 0
5392                 string src = Config->get_ltc_sink_port();
5393
5394                 _ltc_output->disconnect (this);
5395
5396                 if (src != _("None") && !src.empty())  {
5397                         _ltc_output->nth (0)->connect (src);
5398                 }
5399 #endif
5400         }
5401 }