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