libs/ardour/session.cc

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