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                         std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3347
3348                         snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3349
3350                         if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3351                                 existing++;
3352                         }
3353                 }
3354
3355                 if (existing == 0) {
3356                         break;
3357                 }
3358
3359                 if (cnt > limit) {
3360                         error << string_compose(
3361                                         _("There are already %1 recordings for %2, which I consider too many."),
3362                                         limit, base) << endmsg;
3363                         destroy ();
3364                         throw failed_constructor();
3365                 }
3366         }
3367
3368         return Glib::path_get_basename(buf);
3369 }
3370
3371
3372 /** Create a new within-session MIDI source */
3373 boost::shared_ptr<MidiSource>
3374 Session::create_midi_source_for_session (Track* track, string const & n)
3375 {
3376         /* try to use the existing write source for the track, to keep numbering sane
3377          */
3378
3379         if (track) {
3380                 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3381                   assert (mt);
3382                 */
3383
3384                 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3385
3386                 if (!l.empty()) {
3387                         assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3388                         return boost::dynamic_pointer_cast<MidiSource> (l.front());
3389                 }
3390         }
3391
3392         const string name = new_midi_source_name (n);
3393         const string path = new_source_path_from_name (DataType::MIDI, name);
3394
3395         return boost::dynamic_pointer_cast<SMFSource> (
3396                 SourceFactory::createWritable (
3397                         DataType::MIDI, *this, path, string(), false, frame_rate()));
3398 }
3399
3400
3401 void
3402 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3403 {
3404         if (playlist->hidden()) {
3405                 return;
3406         }
3407
3408         playlists->add (playlist);
3409
3410         if (unused) {
3411                 playlist->release();
3412         }
3413
3414         set_dirty();
3415 }
3416
3417 void
3418 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3419 {
3420         if (_state_of_the_state & Deletion) {
3421                 return;
3422         }
3423
3424         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3425
3426         if (!playlist) {
3427                 return;
3428         }
3429
3430         playlists->remove (playlist);
3431
3432         set_dirty();
3433 }
3434
3435 void
3436 Session::set_audition (boost::shared_ptr<Region> r)
3437 {
3438         pending_audition_region = r;
3439         add_post_transport_work (PostTransportAudition);
3440         _butler->schedule_transport_work ();
3441 }
3442
3443 void
3444 Session::audition_playlist ()
3445 {
3446         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3447         ev->region.reset ();
3448         queue_event (ev);
3449 }
3450
3451 void
3452 Session::non_realtime_set_audition ()
3453 {
3454         assert (pending_audition_region);
3455         auditioner->audition_region (pending_audition_region);
3456         pending_audition_region.reset ();
3457         AuditionActive (true); /* EMIT SIGNAL */
3458 }
3459
3460 void
3461 Session::audition_region (boost::shared_ptr<Region> r)
3462 {
3463         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3464         ev->region = r;
3465         queue_event (ev);
3466 }
3467
3468 void
3469 Session::cancel_audition ()
3470 {
3471         if (auditioner->auditioning()) {
3472                 auditioner->cancel_audition ();
3473                 AuditionActive (false); /* EMIT SIGNAL */
3474         }
3475 }
3476
3477 bool
3478 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3479 {
3480         if (a->is_monitor()) {
3481                 return true;
3482         }
3483         if (b->is_monitor()) {
3484                 return false;
3485         }
3486         return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3487 }
3488
3489 bool
3490 Session::is_auditioning () const
3491 {
3492         /* can be called before we have an auditioner object */
3493         if (auditioner) {
3494                 return auditioner->auditioning();
3495         } else {
3496                 return false;
3497         }
3498 }
3499
3500 void
3501 Session::graph_reordered ()
3502 {
3503         /* don't do this stuff if we are setting up connections
3504            from a set_state() call or creating new tracks. Ditto for deletion.
3505         */
3506
3507         if (_state_of_the_state & (InitialConnecting|Deletion)) {
3508                 return;
3509         }
3510
3511         /* every track/bus asked for this to be handled but it was deferred because
3512            we were connecting. do it now.
3513         */
3514
3515         request_input_change_handling ();
3516
3517         resort_routes ();
3518
3519         /* force all diskstreams to update their capture offset values to
3520            reflect any changes in latencies within the graph.
3521         */
3522
3523         boost::shared_ptr<RouteList> rl = routes.reader ();
3524         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3525                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3526                 if (tr) {
3527                         tr->set_capture_offset ();
3528                 }
3529         }
3530 }
3531
3532 /** @return Number of frames that there is disk space available to write,
3533  *  if known.
3534  */
3535 boost::optional<framecnt_t>
3536 Session::available_capture_duration ()
3537 {
3538         if (_total_free_4k_blocks_uncertain) {
3539                 return boost::optional<framecnt_t> ();
3540         }
3541
3542         float sample_bytes_on_disk = 4.0; // keep gcc happy
3543
3544         switch (config.get_native_file_data_format()) {
3545         case FormatFloat:
3546                 sample_bytes_on_disk = 4.0;
3547                 break;
3548
3549         case FormatInt24:
3550                 sample_bytes_on_disk = 3.0;
3551                 break;
3552
3553         case FormatInt16:
3554                 sample_bytes_on_disk = 2.0;
3555                 break;
3556
3557         default:
3558                 /* impossible, but keep some gcc versions happy */
3559                 fatal << string_compose (_("programming error: %1"),
3560                                          X_("illegal native file data format"))
3561                       << endmsg;
3562                 /*NOTREACHED*/
3563         }
3564
3565         double scale = 4096.0 / sample_bytes_on_disk;
3566
3567         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3568                 return max_framecnt;
3569         }
3570
3571         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3572 }
3573
3574 void
3575 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3576 {
3577         {
3578                 RCUWriter<BundleList> writer (_bundles);
3579                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3580                 b->push_back (bundle);
3581         }
3582
3583         BundleAdded (bundle); /* EMIT SIGNAL */
3584
3585         set_dirty();
3586 }
3587
3588 void
3589 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3590 {
3591         bool removed = false;
3592
3593         {
3594                 RCUWriter<BundleList> writer (_bundles);
3595                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3596                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3597
3598                 if (i != b->end()) {
3599                         b->erase (i);
3600                         removed = true;
3601                 }
3602         }
3603
3604         if (removed) {
3605                  BundleRemoved (bundle); /* EMIT SIGNAL */
3606         }
3607
3608         set_dirty();
3609 }
3610
3611 boost::shared_ptr<Bundle>
3612 Session::bundle_by_name (string name) const
3613 {
3614         boost::shared_ptr<BundleList> b = _bundles.reader ();
3615
3616         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3617                 if ((*i)->name() == name) {
3618                         return* i;
3619                 }
3620         }
3621
3622         return boost::shared_ptr<Bundle> ();
3623 }
3624
3625 void
3626 Session::tempo_map_changed (const PropertyChange&)
3627 {
3628         clear_clicks ();
3629
3630         playlists->update_after_tempo_map_change ();
3631
3632         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3633
3634         set_dirty ();
3635 }
3636
3637 void
3638 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3639 {
3640         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3641                 (*i)->recompute_frames_from_bbt ();
3642         }
3643 }
3644
3645 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3646  * the given count with the current block size.
3647  */
3648 void
3649 Session::ensure_buffers (ChanCount howmany)
3650 {
3651         BufferManager::ensure_buffers (howmany);
3652 }
3653
3654 void
3655 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3656 {
3657         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3658                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3659         }
3660 }
3661
3662 uint32_t
3663 Session::next_insert_id ()
3664 {
3665         /* this doesn't really loop forever. just think about it */
3666
3667         while (true) {
3668                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3669                         if (!insert_bitset[n]) {
3670                                 insert_bitset[n] = true;
3671                                 return n;
3672
3673                         }
3674                 }
3675
3676                 /* none available, so resize and try again */
3677
3678                 insert_bitset.resize (insert_bitset.size() + 16, false);
3679         }
3680 }
3681
3682 uint32_t
3683 Session::next_send_id ()
3684 {
3685         /* this doesn't really loop forever. just think about it */
3686
3687         while (true) {
3688                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3689                         if (!send_bitset[n]) {
3690                                 send_bitset[n] = true;
3691                                 return n;
3692
3693                         }
3694                 }
3695
3696                 /* none available, so resize and try again */
3697
3698                 send_bitset.resize (send_bitset.size() + 16, false);
3699         }
3700 }
3701
3702 uint32_t
3703 Session::next_aux_send_id ()
3704 {
3705         /* this doesn't really loop forever. just think about it */
3706
3707         while (true) {
3708                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3709                         if (!aux_send_bitset[n]) {
3710                                 aux_send_bitset[n] = true;
3711                                 return n;
3712
3713                         }
3714                 }
3715
3716                 /* none available, so resize and try again */
3717
3718                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3719         }
3720 }
3721
3722 uint32_t
3723 Session::next_return_id ()
3724 {
3725         /* this doesn't really loop forever. just think about it */
3726
3727         while (true) {
3728                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3729                         if (!return_bitset[n]) {
3730                                 return_bitset[n] = true;
3731                                 return n;
3732
3733                         }
3734                 }
3735
3736                 /* none available, so resize and try again */
3737
3738                 return_bitset.resize (return_bitset.size() + 16, false);
3739         }
3740 }
3741
3742 void
3743 Session::mark_send_id (uint32_t id)
3744 {
3745         if (id >= send_bitset.size()) {
3746                 send_bitset.resize (id+16, false);
3747         }
3748         if (send_bitset[id]) {
3749                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3750         }
3751         send_bitset[id] = true;
3752 }
3753
3754 void
3755 Session::mark_aux_send_id (uint32_t id)
3756 {
3757         if (id >= aux_send_bitset.size()) {
3758                 aux_send_bitset.resize (id+16, false);
3759         }
3760         if (aux_send_bitset[id]) {
3761                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3762         }
3763         aux_send_bitset[id] = true;
3764 }
3765
3766 void
3767 Session::mark_return_id (uint32_t id)
3768 {
3769         if (id >= return_bitset.size()) {
3770                 return_bitset.resize (id+16, false);
3771         }
3772         if (return_bitset[id]) {
3773                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3774         }
3775         return_bitset[id] = true;
3776 }
3777
3778 void
3779 Session::mark_insert_id (uint32_t id)
3780 {
3781         if (id >= insert_bitset.size()) {
3782                 insert_bitset.resize (id+16, false);
3783         }
3784         if (insert_bitset[id]) {
3785                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3786         }
3787         insert_bitset[id] = true;
3788 }
3789
3790 void
3791 Session::unmark_send_id (uint32_t id)
3792 {
3793         if (id < send_bitset.size()) {
3794                 send_bitset[id] = false;
3795         }
3796 }
3797
3798 void
3799 Session::unmark_aux_send_id (uint32_t id)
3800 {
3801         if (id < aux_send_bitset.size()) {
3802                 aux_send_bitset[id] = false;
3803         }
3804 }
3805
3806 void
3807 Session::unmark_return_id (uint32_t id)
3808 {
3809         if (id < return_bitset.size()) {
3810                 return_bitset[id] = false;
3811         }
3812 }
3813
3814 void
3815 Session::unmark_insert_id (uint32_t id)
3816 {
3817         if (id < insert_bitset.size()) {
3818                 insert_bitset[id] = false;
3819         }
3820 }
3821
3822
3823 /* Named Selection management */
3824
3825 boost::shared_ptr<NamedSelection>
3826 Session::named_selection_by_name (string name)
3827 {
3828         Glib::Mutex::Lock lm (named_selection_lock);
3829         for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3830                 if ((*i)->name == name) {
3831                         return *i;
3832                 }
3833         }
3834         return boost::shared_ptr<NamedSelection>();
3835 }
3836
3837 void
3838 Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3839 {
3840         {
3841                 Glib::Mutex::Lock lm (named_selection_lock);
3842                 named_selections.insert (named_selections.begin(), named_selection);
3843         }
3844
3845         set_dirty();
3846
3847         NamedSelectionAdded (); /* EMIT SIGNAL */
3848 }
3849
3850 void
3851 Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3852 {
3853         bool removed = false;
3854
3855         {
3856                 Glib::Mutex::Lock lm (named_selection_lock);
3857
3858                 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3859
3860                 if (i != named_selections.end()) {
3861                         named_selections.erase (i);
3862                         set_dirty();
3863                         removed = true;
3864                 }
3865         }
3866
3867         if (removed) {
3868                  NamedSelectionRemoved (); /* EMIT SIGNAL */
3869         }
3870 }
3871
3872 void
3873 Session::reset_native_file_format ()
3874 {
3875         boost::shared_ptr<RouteList> rl = routes.reader ();
3876         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3877                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3878                 if (tr) {
3879                         /* don't save state as we do this, there's no point
3880                          */
3881
3882                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3883                         tr->reset_write_sources (false);
3884                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3885                 }
3886         }
3887 }
3888
3889 bool
3890 Session::route_name_unique (string n) const
3891 {
3892         boost::shared_ptr<RouteList> r = routes.reader ();
3893
3894         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3895                 if ((*i)->name() == n) {
3896                         return false;
3897                 }
3898         }
3899
3900         return true;
3901 }
3902
3903 bool
3904 Session::route_name_internal (string n) const
3905 {
3906         if (auditioner && auditioner->name() == n) {
3907                 return true;
3908         }
3909
3910         if (_click_io && _click_io->name() == n) {
3911                 return true;
3912         }
3913
3914         return false;
3915 }
3916
3917 int
3918 Session::freeze_all (InterThreadInfo& itt)
3919 {
3920         boost::shared_ptr<RouteList> r = routes.reader ();
3921
3922         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3923
3924                 boost::shared_ptr<Track> t;
3925
3926                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3927                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3928                            of every track.
3929                         */
3930                         t->freeze_me (itt);
3931                 }
3932         }
3933
3934         return 0;
3935 }
3936
3937 boost::shared_ptr<Region>
3938 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3939                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3940                           InterThreadInfo& itt,
3941                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
3942                           bool for_export)
3943 {
3944         boost::shared_ptr<Region> result;
3945         boost::shared_ptr<Playlist> playlist;
3946         boost::shared_ptr<AudioFileSource> fsource;
3947         uint32_t x;
3948         char buf[PATH_MAX+1];
3949         ChanCount diskstream_channels (track.n_channels());
3950         framepos_t position;
3951         framecnt_t this_chunk;
3952         framepos_t to_do;
3953         BufferSet buffers;
3954         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3955         const string sound_dir = sdir.sound_path();
3956         framepos_t len = end - start;
3957         bool need_block_size_reset = false;
3958         string ext;
3959         ChanCount const max_proc = track.max_processor_streams ();
3960
3961         if (end <= start) {
3962                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3963                                          end, start) << endmsg;
3964                 return result;
3965         }
3966
3967         const framecnt_t chunk_size = (256 * 1024)/4;
3968
3969         // block all process callback handling
3970
3971         block_processing ();
3972
3973         /* call tree *MUST* hold route_lock */
3974
3975         if ((playlist = track.playlist()) == 0) {
3976                 goto out;
3977         }
3978
3979         ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3980
3981         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3982
3983                 for (x = 0; x < 99999; ++x) {
3984                         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());
3985                         if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3986                                 break;
3987                         }
3988                 }
3989
3990                 if (x == 99999) {
3991                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3992                         goto out;
3993                 }
3994
3995                 try {
3996                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3997                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
3998                 }
3999
4000                 catch (failed_constructor& err) {
4001                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4002                         goto out;
4003                 }
4004
4005                 srcs.push_back (fsource);
4006         }
4007
4008         /* tell redirects that care that we are about to use a much larger
4009          * blocksize. this will flush all plugins too, so that they are ready
4010          * to be used for this process.
4011          */
4012
4013         need_block_size_reset = true;
4014         track.set_block_size (chunk_size);
4015
4016         position = start;
4017         to_do = len;
4018
4019         /* create a set of reasonably-sized buffers */
4020         buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4021         buffers.set_count (max_proc);
4022
4023         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4024                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4025                 if (afs)
4026                         afs->prepare_for_peakfile_writes ();
4027         }
4028
4029         while (to_do && !itt.cancel) {
4030
4031                 this_chunk = min (to_do, chunk_size);
4032
4033                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4034                         goto out;
4035                 }
4036
4037                 uint32_t n = 0;
4038                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4039                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4040
4041                         if (afs) {
4042                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4043                                         goto out;
4044                                 }
4045                         }
4046                 }
4047
4048                 start += this_chunk;
4049                 to_do -= this_chunk;
4050
4051                 itt.progress = (float) (1.0 - ((double) to_do / len));
4052
4053         }
4054
4055         if (!itt.cancel) {
4056
4057                 time_t now;
4058                 struct tm* xnow;
4059                 time (&now);
4060                 xnow = localtime (&now);
4061
4062                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4063                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4064
4065                         if (afs) {
4066                                 afs->update_header (position, *xnow, now);
4067                                 afs->flush_header ();
4068                         }
4069                 }
4070
4071                 /* construct a region to represent the bounced material */
4072
4073                 PropertyList plist;
4074
4075                 plist.add (Properties::start, 0);
4076                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4077                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4078
4079                 result = RegionFactory::create (srcs, plist);
4080
4081         }
4082
4083   out:
4084         if (!result) {
4085                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4086                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4087
4088                         if (afs) {
4089                                 afs->mark_for_remove ();
4090                         }
4091
4092                         (*src)->drop_references ();
4093                 }
4094
4095         } else {
4096                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4097                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4098
4099                         if (afs)
4100                                 afs->done_with_peakfile_writes ();
4101                 }
4102         }
4103
4104
4105         if (need_block_size_reset) {
4106                 track.set_block_size (get_block_size());
4107         }
4108
4109         unblock_processing ();
4110
4111         return result;
4112 }
4113
4114 gain_t*
4115 Session::gain_automation_buffer() const
4116 {
4117         return ProcessThread::gain_automation_buffer ();
4118 }
4119
4120 gain_t*
4121 Session::send_gain_automation_buffer() const
4122 {
4123         return ProcessThread::send_gain_automation_buffer ();
4124 }
4125
4126 pan_t**
4127 Session::pan_automation_buffer() const
4128 {
4129         return ProcessThread::pan_automation_buffer ();
4130 }
4131
4132 BufferSet&
4133 Session::get_silent_buffers (ChanCount count)
4134 {
4135         return ProcessThread::get_silent_buffers (count);
4136 }
4137
4138 BufferSet&
4139 Session::get_scratch_buffers (ChanCount count)
4140 {
4141         return ProcessThread::get_scratch_buffers (count);
4142 }
4143
4144 BufferSet&
4145 Session::get_mix_buffers (ChanCount count)
4146 {
4147         return ProcessThread::get_mix_buffers (count);
4148 }
4149
4150 uint32_t
4151 Session::ntracks () const
4152 {
4153         uint32_t n = 0;
4154         boost::shared_ptr<RouteList> r = routes.reader ();
4155
4156         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4157                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4158                         ++n;
4159                 }
4160         }
4161
4162         return n;
4163 }
4164
4165 uint32_t
4166 Session::nbusses () const
4167 {
4168         uint32_t n = 0;
4169         boost::shared_ptr<RouteList> r = routes.reader ();
4170
4171         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4172                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4173                         ++n;
4174                 }
4175         }
4176
4177         return n;
4178 }
4179
4180 void
4181 Session::add_automation_list(AutomationList *al)
4182 {
4183         automation_lists[al->id()] = al;
4184 }
4185
4186 void
4187 Session::sync_order_keys (std::string const & base)
4188 {
4189         if (deletion_in_progress()) {
4190                 return;
4191         }
4192
4193         if (!Config->get_sync_all_route_ordering()) {
4194                 /* leave order keys as they are */
4195                 return;
4196         }
4197
4198         boost::shared_ptr<RouteList> r = routes.reader ();
4199
4200         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4201                 (*i)->sync_order_keys (base);
4202         }
4203
4204         Route::SyncOrderKeys (base); // EMIT SIGNAL
4205
4206         /* this might not do anything */
4207
4208         set_remote_control_ids ();
4209 }
4210
4211 /** @return true if there is at least one record-enabled track, otherwise false */
4212 bool
4213 Session::have_rec_enabled_track () const
4214 {
4215         return g_atomic_int_get (&_have_rec_enabled_track) == 1;
4216 }
4217
4218 /** Update the state of our rec-enabled tracks flag */
4219 void
4220 Session::update_have_rec_enabled_track ()
4221 {
4222         boost::shared_ptr<RouteList> rl = routes.reader ();
4223         RouteList::iterator i = rl->begin();
4224         while (i != rl->end ()) {
4225
4226                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4227                 if (tr && tr->record_enabled ()) {
4228                         break;
4229                 }
4230
4231                 ++i;
4232         }
4233
4234         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4235
4236         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4237
4238         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4239                 RecordStateChanged (); /* EMIT SIGNAL */
4240         }
4241 }
4242
4243 void
4244 Session::listen_position_changed ()
4245 {
4246         boost::shared_ptr<RouteList> r = routes.reader ();
4247
4248         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4249                 (*i)->listen_position_changed ();
4250         }
4251 }
4252
4253 void
4254 Session::solo_control_mode_changed ()
4255 {
4256         /* cancel all solo or all listen when solo control mode changes */
4257
4258         if (soloing()) {
4259                 set_solo (get_routes(), false);
4260         } else if (listening()) {
4261                 set_listen (get_routes(), false);
4262         }
4263 }
4264
4265 /** Called when a property of one of our route groups changes */
4266 void
4267 Session::route_group_property_changed (RouteGroup* rg)
4268 {
4269         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4270 }
4271
4272 /** Called when a route is added to one of our route groups */
4273 void
4274 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4275 {
4276         RouteAddedToRouteGroup (rg, r);
4277 }
4278
4279 /** Called when a route is removed from one of our route groups */
4280 void
4281 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4282 {
4283         RouteRemovedFromRouteGroup (rg, r);
4284 }
4285
4286 vector<SyncSource>
4287 Session::get_available_sync_options () const
4288 {
4289         vector<SyncSource> ret;
4290
4291         ret.push_back (JACK);
4292         ret.push_back (MTC);
4293         ret.push_back (MIDIClock);
4294
4295         return ret;
4296 }
4297
4298 boost::shared_ptr<RouteList>
4299 Session::get_routes_with_regions_at (framepos_t const p) const
4300 {
4301         boost::shared_ptr<RouteList> r = routes.reader ();
4302         boost::shared_ptr<RouteList> rl (new RouteList);
4303
4304         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4305                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4306                 if (!tr) {
4307                         continue;
4308                 }
4309
4310                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4311                 if (!pl) {
4312                         continue;
4313                 }
4314
4315                 if (pl->has_region_at (p)) {
4316                         rl->push_back (*i);
4317                 }
4318         }
4319
4320         return rl;
4321 }
4322
4323 void
4324 Session::goto_end ()
4325 {
4326         if (_session_range_location) {
4327                 request_locate (_session_range_location->end(), false);
4328         } else {
4329                 request_locate (0, false);
4330         }
4331 }
4332
4333 void
4334 Session::goto_start ()
4335 {
4336         if (_session_range_location) {
4337                 request_locate (_session_range_location->start(), false);
4338         } else {
4339                 request_locate (0, false);
4340         }
4341 }
4342
4343 framepos_t
4344 Session::current_start_frame () const
4345 {
4346         return _session_range_location ? _session_range_location->start() : 0;
4347 }
4348
4349 framepos_t
4350 Session::current_end_frame () const
4351 {
4352         return _session_range_location ? _session_range_location->end() : 0;
4353 }
4354
4355 void
4356 Session::add_session_range_location (framepos_t start, framepos_t end)
4357 {
4358         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4359         _locations->add (_session_range_location);
4360 }
4361
4362 /** Called when one of our routes' order keys has changed */
4363 void
4364 Session::route_order_key_changed ()
4365 {
4366         RouteOrderKeyChanged (); /* EMIT SIGNAL */
4367 }
4368
4369 void
4370 Session::step_edit_status_change (bool yn)
4371 {
4372         bool send = false;
4373
4374         bool val = false;
4375         if (yn) {
4376                 send = (_step_editors == 0);
4377                 val = true;
4378
4379                 _step_editors++;
4380         } else {
4381                 send = (_step_editors == 1);
4382                 val = false;
4383
4384                 if (_step_editors > 0) {
4385                         _step_editors--;
4386                 }
4387         }
4388
4389         if (send) {
4390                 StepEditStatusChange (val);
4391         }
4392 }
4393
4394
4395 void
4396 Session::start_time_changed (framepos_t old)
4397 {
4398         /* Update the auto loop range to match the session range
4399            (unless the auto loop range has been changed by the user)
4400         */
4401
4402         Location* s = _locations->session_range_location ();
4403         if (s == 0) {
4404                 return;
4405         }
4406
4407         Location* l = _locations->auto_loop_location ();
4408
4409         if (l && l->start() == old) {
4410                 l->set_start (s->start(), true);
4411         }
4412 }
4413
4414 void
4415 Session::end_time_changed (framepos_t old)
4416 {
4417         /* Update the auto loop range to match the session range
4418            (unless the auto loop range has been changed by the user)
4419         */
4420
4421         Location* s = _locations->session_range_location ();
4422         if (s == 0) {
4423                 return;
4424         }
4425
4426         Location* l = _locations->auto_loop_location ();
4427
4428         if (l && l->end() == old) {
4429                 l->set_end (s->end(), true);
4430         }
4431 }
4432
4433 string
4434 Session::source_search_path (DataType type) const
4435 {
4436         vector<string> s;
4437
4438         if (session_dirs.size() == 1) {
4439                 switch (type) {
4440                 case DataType::AUDIO:
4441                         s.push_back ( _session_dir->sound_path());
4442                         break;
4443                 case DataType::MIDI:
4444                         s.push_back (_session_dir->midi_path());
4445                         break;
4446                 }
4447         } else {
4448                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4449                         SessionDirectory sdir (i->path);
4450                         switch (type) {
4451                         case DataType::AUDIO:
4452                                 s.push_back (sdir.sound_path());
4453                                 break;
4454                         case DataType::MIDI:
4455                                 s.push_back (sdir.midi_path());
4456                                 break;
4457                         }
4458                 }
4459         }
4460
4461         /* now check the explicit (possibly user-specified) search path
4462          */
4463
4464         vector<string> dirs;
4465
4466         switch (type) {
4467         case DataType::AUDIO:
4468                 split (config.get_audio_search_path (), dirs, ':');
4469                 break;
4470         case DataType::MIDI:
4471                 split (config.get_midi_search_path (), dirs, ':');
4472                 break;
4473         }
4474
4475         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4476
4477                 vector<string>::iterator si;
4478
4479                 for (si = s.begin(); si != s.end(); ++si) {
4480                         if ((*si) == *i) {
4481                                 break;
4482                         }
4483                 }
4484
4485                 if (si == s.end()) {
4486                         s.push_back (*i);
4487                 }
4488         }
4489
4490         string search_path;
4491
4492         for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4493                 if (!search_path.empty()) {
4494                         search_path += ':';
4495                 }
4496                 search_path += *si;
4497         }
4498
4499         return search_path;
4500 }
4501
4502 void
4503 Session::ensure_search_path_includes (const string& path, DataType type)
4504 {
4505         string search_path;
4506         vector<string> dirs;
4507
4508         if (path == ".") {
4509                 return;
4510         }
4511
4512         switch (type) {
4513         case DataType::AUDIO:
4514                 search_path = config.get_audio_search_path ();
4515                 break;
4516         case DataType::MIDI:
4517                 search_path = config.get_midi_search_path ();
4518                 break;
4519         }
4520
4521         split (search_path, dirs, ':');
4522
4523         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4524                 /* No need to add this new directory if it has the same inode as
4525                    an existing one; checking inode rather than name prevents duplicated
4526                    directories when we are using symlinks.
4527
4528                    On Windows, I think we could just do if (*i == path) here.
4529                 */
4530                 if (PBD::equivalent_paths (*i, path)) {
4531                         return;
4532                 }
4533         }
4534
4535         if (!search_path.empty()) {
4536                 search_path += ':';
4537         }
4538
4539         search_path += path;
4540
4541         switch (type) {
4542         case DataType::AUDIO:
4543                 config.set_audio_search_path (search_path);
4544                 break;
4545         case DataType::MIDI:
4546                 config.set_midi_search_path (search_path);
4547                 break;
4548         }
4549 }
4550
4551 boost::shared_ptr<Speakers>
4552 Session::get_speakers()
4553 {
4554         return _speakers;
4555 }
4556
4557 list<string>
4558 Session::unknown_processors () const
4559 {
4560         list<string> p;
4561
4562         boost::shared_ptr<RouteList> r = routes.reader ();
4563         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4564                 list<string> t = (*i)->unknown_processors ();
4565                 copy (t.begin(), t.end(), back_inserter (p));
4566         }
4567
4568         p.sort ();
4569         p.unique ();
4570
4571         return p;
4572 }
4573
4574 void
4575 Session::update_latency (bool playback)
4576 {
4577         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4578
4579         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4580                 return;
4581         }
4582
4583         boost::shared_ptr<RouteList> r = routes.reader ();
4584         framecnt_t max_latency = 0;
4585
4586         if (playback) {
4587                 /* reverse the list so that we work backwards from the last route to run to the first */
4588                 RouteList* rl = routes.reader().get();
4589                 r.reset (new RouteList (*rl));
4590                 reverse (r->begin(), r->end());
4591         }
4592
4593         /* compute actual latency values for the given direction and store them all in per-port
4594            structures. this will also publish the same values (to JACK) so that computation of latency
4595            for routes can consistently use public latency values.
4596         */
4597
4598         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4599                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4600         }
4601
4602         /* because we latency compensate playback, our published playback latencies should
4603            be the same for all output ports - all material played back by ardour has
4604            the same latency, whether its caused by plugins or by latency compensation. since
4605            these may differ from the values computed above, reset all playback port latencies
4606            to the same value.
4607         */
4608
4609         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4610
4611         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4612                 (*i)->set_public_port_latencies (max_latency, playback);
4613         }
4614
4615         if (playback) {
4616
4617                 post_playback_latency ();
4618
4619         } else {
4620
4621                 post_capture_latency ();
4622         }
4623
4624         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4625 }
4626
4627 void
4628 Session::post_playback_latency ()
4629 {
4630         set_worst_playback_latency ();
4631
4632         boost::shared_ptr<RouteList> r = routes.reader ();
4633
4634         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4635                 if (!(*i)->is_hidden() && ((*i)->active())) {
4636                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4637                 }
4638         }
4639
4640         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4641                 (*i)->set_latency_compensation (_worst_track_latency);
4642         }
4643 }
4644
4645 void
4646 Session::post_capture_latency ()
4647 {
4648         set_worst_capture_latency ();
4649
4650         /* reflect any changes in capture latencies into capture offsets
4651          */
4652
4653         boost::shared_ptr<RouteList> rl = routes.reader();
4654         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4655                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4656                 if (tr) {
4657                         tr->set_capture_offset ();
4658                 }
4659         }
4660 }
4661
4662 void
4663 Session::initialize_latencies ()
4664 {
4665         {
4666                 Glib::Mutex::Lock lm (_engine.process_lock());
4667                 update_latency (false);
4668                 update_latency (true);
4669         }
4670
4671         set_worst_io_latencies ();
4672 }
4673
4674 void
4675 Session::set_worst_io_latencies ()
4676 {
4677         set_worst_playback_latency ();
4678         set_worst_capture_latency ();
4679 }
4680
4681 void
4682 Session::set_worst_playback_latency ()
4683 {
4684         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4685                 return;
4686         }
4687
4688         _worst_output_latency = 0;
4689
4690         if (!_engine.connected()) {
4691                 return;
4692         }
4693
4694         boost::shared_ptr<RouteList> r = routes.reader ();
4695
4696         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4697                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4698         }
4699
4700         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4701 }
4702
4703 void
4704 Session::set_worst_capture_latency ()
4705 {
4706         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4707                 return;
4708         }
4709
4710         _worst_input_latency = 0;
4711
4712         if (!_engine.connected()) {
4713                 return;
4714         }
4715
4716         boost::shared_ptr<RouteList> r = routes.reader ();
4717
4718         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4719                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4720         }
4721
4722         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4723 }
4724
4725 void
4726 Session::update_latency_compensation (bool force_whole_graph)
4727 {
4728         bool some_track_latency_changed = false;
4729
4730         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4731                 return;
4732         }
4733
4734         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4735
4736         _worst_track_latency = 0;
4737
4738         boost::shared_ptr<RouteList> r = routes.reader ();
4739
4740         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4741                 if (!(*i)->is_hidden() && ((*i)->active())) {
4742                         framecnt_t tl;
4743                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4744                                 some_track_latency_changed = true;
4745                         }
4746                         _worst_track_latency = max (tl, _worst_track_latency);
4747                 }
4748         }
4749
4750         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4751                                                      (some_track_latency_changed ? "yes" : "no")));
4752
4753         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4754
4755         if (some_track_latency_changed || force_whole_graph)  {
4756                 _engine.update_latencies ();
4757         }
4758
4759
4760         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4761                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4762                 if (!tr) {
4763                         continue;
4764                 }
4765                 tr->set_capture_offset ();
4766         }
4767 }
4768
4769 char
4770 Session::session_name_is_legal (const string& path)
4771 {
4772         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4773
4774         for (int i = 0; illegal_chars[i]; ++i) {
4775                 if (path.find (illegal_chars[i]) != string::npos) {
4776                         return illegal_chars[i];
4777                 }
4778         }
4779
4780         return 0;
4781 }
4782
4783 uint32_t
4784 Session::next_control_id () const
4785 {
4786         return ntracks() + nbusses() + 1;
4787 }
4788
4789 bool
4790 Session::operation_in_progress (GQuark op) const
4791 {
4792         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4793 }