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