libs/ardour/session.cc

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