libs/ardour/session.cc

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