libs/ardour/session.cc

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