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