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