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