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