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