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