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