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         ltc_encoder = NULL;
 156
 157         if (how_many_dsp_threads () > 1) {
 158                 /* For now, only create the graph if we are using >1 DSP threads, as
 159                    it is a bit slower than the old code with 1 thread.
 160                 */
 161                 _process_graph.reset (new Graph (*this));
 162         }
 163
 164         playlists.reset (new SessionPlaylists);
 165
 166         _all_route_group->set_active (true, this);
 167
 168         interpolation.add_channel_to (0, 0);
 169
 170         if (!eng.connected()) {
 171                 throw failed_constructor();
 172         }
 173
 174         n_physical_outputs = _engine.n_physical_outputs ();
 175         n_physical_inputs =  _engine.n_physical_inputs ();
 176
 177         first_stage_init (fullpath, snapshot_name);
 178
 179         _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
 180
 181         if (_is_new) {
 182                 if (create (mix_template, bus_profile)) {
 183                         destroy ();
 184                         throw failed_constructor ();
 185                 }
 186         }
 187
 188         if (second_stage_init ()) {
 189                 destroy ();
 190                 throw failed_constructor ();
 191         }
 192
 193         store_recent_sessions(_name, _path);
 194
 195         bool was_dirty = dirty();
 196
 197         _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
 198
 199         Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
 200         config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
 201
 202         if (was_dirty) {
 203                 DirtyChanged (); /* EMIT SIGNAL */
 204         }
 205
 206         StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
 207         EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
 208
 209         _is_new = false;
 210 }
 211
 212 Session::~Session ()
 213 {
 214 #ifdef PT_TIMING
 215         ST.dump ("ST.dump");
 216 #endif
 217         destroy ();
 218 }
 219
 220 void
 221 Session::destroy ()
 222 {
 223         vector<void*> debug_pointers;
 224
 225         /* if we got to here, leaving pending capture state around
 226            is a mistake.
 227         */
 228
 229         remove_pending_capture_state ();
 230
 231         _state_of_the_state = StateOfTheState (CannotSave|Deletion);
 232
 233         /* disconnect from any and all signals that we are connected to */
 234
 235         drop_connections ();
 236
 237         _engine.remove_session ();
 238
 239         /* deregister all ports - there will be no process or any other
 240          * callbacks from the engine any more.
 241          */
 242
 243         Port::PortDrop (); /* EMIT SIGNAL */
 244
 245         ltc_tx_cleanup();
 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 << _("You cannot use this location for auto-loop because it has zero or negative length") << 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         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1638
1639         while (how_many) {
1640                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1641                         error << "cannot find name for new midi track" << endmsg;
1642                         goto failed;
1643                 }
1644
1645                 boost::shared_ptr<MidiTrack> track;
1646
1647                 try {
1648                         track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1649
1650                         if (track->init ()) {
1651                                 goto failed;
1652                         }
1653
1654                         track->use_new_diskstream();
1655
1656 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1657                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1658 #endif
1659                         {
1660                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1661                                 if (track->input()->ensure_io (input, false, this)) {
1662                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1663                                         goto failed;
1664                                 }
1665
1666                                 if (track->output()->ensure_io (output, false, this)) {
1667                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1668                                         goto failed;
1669                                 }
1670                         }
1671
1672                         track->non_realtime_input_change();
1673
1674                         if (route_group) {
1675                                 route_group->add (track);
1676                         }
1677
1678                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1679
1680                         if (Config->get_remote_model() == UserOrdered) {
1681                                 track->set_remote_control_id (next_control_id());
1682                         }
1683
1684                         new_routes.push_back (track);
1685                         ret.push_back (track);
1686                 }
1687
1688                 catch (failed_constructor &err) {
1689                         error << _("Session: could not create new midi track.") << endmsg;
1690                         goto failed;
1691                 }
1692
1693                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1694
1695                         error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
1696                         goto failed;
1697                 }
1698
1699                 --how_many;
1700         }
1701
1702   failed:
1703         if (!new_routes.empty()) {
1704                 add_routes (new_routes, true, true, true);
1705
1706                 if (instrument) {
1707                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1708                                 PluginPtr plugin = instrument->load (*this);
1709                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1710                                 (*r)->add_processor (p, PreFader);
1711
1712                         }
1713                 }
1714         }
1715
1716         return ret;
1717 }
1718
1719 void
1720 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1721 {
1722         boost::shared_ptr<Route> midi_track (wmt.lock());
1723
1724         if (!midi_track) {
1725                 return;
1726         }
1727
1728         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1729
1730                 if (change.after.n_audio() <= change.before.n_audio()) {
1731                         return;
1732                 }
1733
1734                 /* new audio ports: make sure the audio goes somewhere useful,
1735                    unless the user has no-auto-connect selected.
1736
1737                    The existing ChanCounts don't matter for this call as they are only
1738                    to do with matching input and output indices, and we are only changing
1739                    outputs here.
1740                 */
1741
1742                 ChanCount dummy;
1743
1744                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1745         }
1746 }
1747
1748 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1749  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1750  *  @param output_start As \a input_start, but for outputs.
1751  */
1752 void
1753 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1754                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1755 {
1756         if (!IO::connecting_legal) {
1757                 return;
1758         }
1759
1760         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1761
1762         if (with_lock) {
1763                 lm.acquire ();
1764         }
1765
1766         /* If both inputs and outputs are auto-connected to physical ports,
1767            use the max of input and output offsets to ensure auto-connected
1768            port numbers always match up (e.g. the first audio input and the
1769            first audio output of the route will have the same physical
1770            port number).  Otherwise just use the lowest input or output
1771            offset possible.
1772         */
1773
1774         DEBUG_TRACE (DEBUG::Graph,
1775                      string_compose("Auto-connect: existing in = %1 out = %2\n",
1776                                     existing_inputs, existing_outputs));
1777
1778         const bool in_out_physical =
1779                 (Config->get_input_auto_connect() & AutoConnectPhysical)
1780                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1781                 && connect_inputs;
1782
1783         const ChanCount in_offset = in_out_physical
1784                 ? ChanCount::max(existing_inputs, existing_outputs)
1785                 : existing_inputs;
1786
1787         const ChanCount out_offset = in_out_physical
1788                 ? ChanCount::max(existing_inputs, existing_outputs)
1789                 : existing_outputs;
1790
1791         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1792                 vector<string> physinputs;
1793                 vector<string> physoutputs;
1794
1795                 _engine.get_physical_outputs (*t, physoutputs);
1796                 _engine.get_physical_inputs (*t, physinputs);
1797
1798                 if (!physinputs.empty() && connect_inputs) {
1799                         uint32_t nphysical_in = physinputs.size();
1800
1801                         DEBUG_TRACE (DEBUG::Graph,
1802                                      string_compose("There are %1 physical inputs of type %2\n",
1803                                                     nphysical_in, *t));
1804
1805                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1806                                 string port;
1807
1808                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1809                                         DEBUG_TRACE (DEBUG::Graph,
1810                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
1811                                                                     in_offset.get(*t), i, nphysical_in,
1812                                                                     (in_offset.get(*t) + i) % nphysical_in));
1813                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1814                                 }
1815
1816                                 DEBUG_TRACE (DEBUG::Graph,
1817                                              string_compose("Connect route %1 IN to %2\n",
1818                                                             route->name(), port));
1819
1820                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1821                                         break;
1822                                 }
1823
1824                                 ChanCount one_added (*t, 1);
1825                                 existing_inputs += one_added;
1826                         }
1827                 }
1828
1829                 if (!physoutputs.empty()) {
1830                         uint32_t nphysical_out = physoutputs.size();
1831                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1832                                 string port;
1833
1834                                 if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
1835                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1836                                 } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
1837                                         /* master bus is audio only */
1838                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1839                                                 port = _master_out->input()->ports().port(*t,
1840                                                                 i % _master_out->input()->n_ports().get(*t))->name();
1841                                         }
1842                                 }
1843
1844                                 DEBUG_TRACE (DEBUG::Graph,
1845                                              string_compose("Connect route %1 OUT to %2\n",
1846                                                             route->name(), port));
1847
1848                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
1849                                         break;
1850                                 }
1851
1852                                 ChanCount one_added (*t, 1);
1853                                 existing_outputs += one_added;
1854                         }
1855                 }
1856         }
1857 }
1858
1859 /** Caller must not hold process lock
1860  *  @param name_template string to use for the start of the name, or "" to use "Audio".
1861  */
1862 list< boost::shared_ptr<AudioTrack> >
1863 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
1864                           uint32_t how_many, string name_template)
1865 {
1866         char track_name[32];
1867         uint32_t track_id = 0;
1868         string port;
1869         RouteList new_routes;
1870         list<boost::shared_ptr<AudioTrack> > ret;
1871
1872         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
1873
1874         while (how_many) {
1875                 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1876                         error << "cannot find name for new audio track" << endmsg;
1877                         goto failed;
1878                 }
1879
1880                 boost::shared_ptr<AudioTrack> track;
1881
1882                 try {
1883                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
1884
1885                         if (track->init ()) {
1886                                 goto failed;
1887                         }
1888
1889                         track->use_new_diskstream();
1890
1891 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1892                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1893 #endif
1894                         {
1895                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1896
1897                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1898                                         error << string_compose (
1899                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
1900                                                 input_channels, output_channels)
1901                                               << endmsg;
1902                                         goto failed;
1903                                 }
1904
1905                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1906                                         error << string_compose (
1907                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
1908                                                 input_channels, output_channels)
1909                                               << endmsg;
1910                                         goto failed;
1911                                 }
1912                         }
1913
1914                         if (route_group) {
1915                                 route_group->add (track);
1916                         }
1917
1918                         track->non_realtime_input_change();
1919
1920                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1921                         if (Config->get_remote_model() == UserOrdered) {
1922                                 track->set_remote_control_id (next_control_id());
1923                         }
1924
1925                         new_routes.push_back (track);
1926                         ret.push_back (track);
1927                 }
1928
1929                 catch (failed_constructor &err) {
1930                         error << _("Session: could not create new audio track.") << endmsg;
1931                         goto failed;
1932                 }
1933
1934                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1935
1936                         error << pfe.what() << endmsg;
1937                         goto failed;
1938                 }
1939
1940                 --how_many;
1941         }
1942
1943   failed:
1944         if (!new_routes.empty()) {
1945                 add_routes (new_routes, true, true, true);
1946         }
1947
1948         return ret;
1949 }
1950
1951 /** Caller must not hold process lock.
1952  *  @param name_template string to use for the start of the name, or "" to use "Bus".
1953  */
1954 RouteList
1955 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
1956 {
1957         char bus_name[32];
1958         uint32_t bus_id = 0;
1959         string port;
1960         RouteList ret;
1961
1962         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
1963
1964         while (how_many) {
1965                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
1966                         error << "cannot find name for new audio bus" << endmsg;
1967                         goto failure;
1968                 }
1969
1970                 try {
1971                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
1972
1973                         if (bus->init ()) {
1974                                 goto failure;
1975                         }
1976
1977 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1978                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
1979 #endif
1980                         {
1981                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1982
1983                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1984                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1985                                                                  input_channels, output_channels)
1986                                               << endmsg;
1987                                         goto failure;
1988                                 }
1989
1990
1991                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1992                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1993                                                                  input_channels, output_channels)
1994                                               << endmsg;
1995                                         goto failure;
1996                                 }
1997                         }
1998
1999                         if (route_group) {
2000                                 route_group->add (bus);
2001                         }
2002                         if (Config->get_remote_model() == UserOrdered) {
2003                                 bus->set_remote_control_id (next_control_id());
2004                         }
2005
2006                         bus->add_internal_return ();
2007
2008                         ret.push_back (bus);
2009
2010                         ARDOUR::GUIIdle ();
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                 ARDOUR::GUIIdle ();
2243         }
2244
2245         if (_monitor_out && IO::connecting_legal) {
2246                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2247
2248                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2249                         if ((*x)->is_monitor()) {
2250                                 /* relax */
2251                         } else if ((*x)->is_master()) {
2252                                         /* relax */
2253                         } else {
2254                                 (*x)->enable_monitor_send ();
2255                         }
2256                 }
2257         }
2258 }
2259
2260 void
2261 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2262 {
2263         boost::shared_ptr<RouteList> r = routes.reader ();
2264         boost::shared_ptr<Send> s;
2265
2266         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2267                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2268                         s->amp()->gain_control()->set_value (0.0);
2269                 }
2270         }
2271 }
2272
2273 void
2274 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2275 {
2276         boost::shared_ptr<RouteList> r = routes.reader ();
2277         boost::shared_ptr<Send> s;
2278
2279         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2280                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2281                         s->amp()->gain_control()->set_value (1.0);
2282                 }
2283         }
2284 }
2285
2286 void
2287 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2288 {
2289         boost::shared_ptr<RouteList> r = routes.reader ();
2290         boost::shared_ptr<Send> s;
2291
2292         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2293                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2294                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2295                 }
2296         }
2297 }
2298
2299 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2300 void
2301 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2302 {
2303         boost::shared_ptr<RouteList> r = routes.reader ();
2304         boost::shared_ptr<RouteList> t (new RouteList);
2305
2306         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2307                 /* no MIDI sends because there are no MIDI busses yet */
2308                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2309                         t->push_back (*i);
2310                 }
2311         }
2312
2313         add_internal_sends (dest, p, t);
2314 }
2315
2316 void
2317 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2318 {
2319         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2320                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2321         }
2322 }
2323
2324 void
2325 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2326 {
2327         add_internal_send (dest, sender->before_processor_for_index (index), sender);
2328 }
2329
2330 void
2331 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2332 {
2333         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2334                 return;
2335         }
2336
2337         if (!dest->internal_return()) {
2338                 dest->add_internal_return ();
2339         }
2340
2341         sender->add_aux_send (dest, before);
2342
2343         graph_reordered ();
2344 }
2345
2346 void
2347 Session::remove_route (boost::shared_ptr<Route> route)
2348 {
2349         if (route == _master_out) {
2350                 return;
2351         }
2352
2353         route->set_solo (false, this);
2354
2355         {
2356                 RCUWriter<RouteList> writer (routes);
2357                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2358
2359                 rs->remove (route);
2360
2361                 /* deleting the master out seems like a dumb
2362                    idea, but its more of a UI policy issue
2363                    than our concern.
2364                 */
2365
2366                 if (route == _master_out) {
2367                         _master_out = boost::shared_ptr<Route> ();
2368                 }
2369
2370                 if (route == _monitor_out) {
2371                         _monitor_out.reset ();
2372                 }
2373
2374                 /* writer goes out of scope, forces route list update */
2375         }
2376
2377         update_route_solo_state ();
2378
2379         // We need to disconnect the route's inputs and outputs
2380
2381         route->input()->disconnect (0);
2382         route->output()->disconnect (0);
2383
2384         /* if the route had internal sends sending to it, remove them */
2385         if (route->internal_return()) {
2386
2387                 boost::shared_ptr<RouteList> r = routes.reader ();
2388                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2389                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2390                         if (s) {
2391                                 (*i)->remove_processor (s);
2392                         }
2393                 }
2394         }
2395
2396         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2397         if (mt && mt->step_editing()) {
2398                 if (_step_editors > 0) {
2399                         _step_editors--;
2400                 }
2401         }
2402
2403         update_latency_compensation ();
2404         set_dirty();
2405
2406         /* Re-sort routes to remove the graph's current references to the one that is
2407          * going away, then flush old references out of the graph.
2408          */
2409
2410         resort_routes ();
2411         if (_process_graph) {
2412                 _process_graph->clear_other_chain ();
2413         }
2414
2415         /* get rid of it from the dead wood collection in the route list manager */
2416
2417         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2418
2419         routes.flush ();
2420
2421         /* try to cause everyone to drop their references */
2422
2423         route->drop_references ();
2424
2425         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2426
2427         /* save the new state of the world */
2428
2429         if (save_state (_current_snapshot_name)) {
2430                 save_history (_current_snapshot_name);
2431         }
2432 }
2433
2434 void
2435 Session::route_mute_changed (void* /*src*/)
2436 {
2437         set_dirty ();
2438 }
2439
2440 void
2441 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2442 {
2443         boost::shared_ptr<Route> route = wpr.lock();
2444         if (!route) {
2445                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2446                 return;
2447         }
2448
2449         if (route->listening_via_monitor ()) {
2450
2451                 if (Config->get_exclusive_solo()) {
2452                         /* new listen: disable all other listen */
2453                         boost::shared_ptr<RouteList> r = routes.reader ();
2454                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2455                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2456                                         continue;
2457                                 }
2458                                 (*i)->set_listen (false, this);
2459                         }
2460                 }
2461
2462                 _listen_cnt++;
2463
2464         } else if (_listen_cnt > 0) {
2465
2466                 _listen_cnt--;
2467         }
2468
2469         update_route_solo_state ();
2470 }
2471 void
2472 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2473 {
2474         boost::shared_ptr<Route> route = wpr.lock ();
2475
2476         if (!route) {
2477                 /* should not happen */
2478                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2479                 return;
2480         }
2481
2482         bool send_changed = false;
2483
2484         if (route->solo_isolated()) {
2485                 if (_solo_isolated_cnt == 0) {
2486                         send_changed = true;
2487                 }
2488                 _solo_isolated_cnt++;
2489         } else if (_solo_isolated_cnt > 0) {
2490                 _solo_isolated_cnt--;
2491                 if (_solo_isolated_cnt == 0) {
2492                         send_changed = true;
2493                 }
2494         }
2495
2496         if (send_changed) {
2497                 IsolatedChanged (); /* EMIT SIGNAL */
2498         }
2499 }
2500
2501 void
2502 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2503 {
2504         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2505
2506         if (!self_solo_change) {
2507                 // session doesn't care about changes to soloed-by-others
2508                 return;
2509         }
2510
2511         if (solo_update_disabled) {
2512                 // We know already
2513                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2514                 return;
2515         }
2516
2517         boost::shared_ptr<Route> route = wpr.lock ();
2518         assert (route);
2519
2520         boost::shared_ptr<RouteList> r = routes.reader ();
2521         int32_t delta;
2522
2523         if (route->self_soloed()) {
2524                 delta = 1;
2525         } else {
2526                 delta = -1;
2527         }
2528
2529         RouteGroup* rg = route->route_group ();
2530         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2531
2532         if (delta == 1 && Config->get_exclusive_solo()) {
2533
2534                 /* new solo: disable all other solos, but not the group if its solo-enabled */
2535
2536                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2537                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2538                             (leave_group_alone && ((*i)->route_group() == rg))) {
2539                                 continue;
2540                         }
2541                         (*i)->set_solo (false, this);
2542                 }
2543         }
2544
2545         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2546
2547         solo_update_disabled = true;
2548
2549         RouteList uninvolved;
2550
2551         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2552
2553         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2554                 bool via_sends_only;
2555                 bool in_signal_flow;
2556
2557                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2558                     (leave_group_alone && ((*i)->route_group() == rg))) {
2559                         continue;
2560                 }
2561
2562                 in_signal_flow = false;
2563
2564                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2565
2566                 if ((*i)->feeds (route, &via_sends_only)) {
2567                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2568                         if (!via_sends_only) {
2569                                 if (!route->soloed_by_others_upstream()) {
2570                                         (*i)->mod_solo_by_others_downstream (delta);
2571                                 }
2572                         } else {
2573                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2574                         }
2575                         in_signal_flow = true;
2576                 } else {
2577                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2578                 }
2579
2580                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2581
2582                 if (route->feeds (*i, &via_sends_only)) {
2583                         /* propagate solo upstream only if routing other than
2584                            sends is involved, but do consider the other route
2585                            (*i) to be part of the signal flow even if only
2586                            sends are involved.
2587                         */
2588                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2589                                                                   route->name(),
2590                                                                   (*i)->name(),
2591                                                                   via_sends_only,
2592                                                                   route->soloed_by_others_downstream(),
2593                                                                   route->soloed_by_others_upstream()));
2594                         if (!via_sends_only) {
2595                                 if (!route->soloed_by_others_downstream()) {
2596                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2597                                         (*i)->mod_solo_by_others_upstream (delta);
2598                                 } else {
2599                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2600                                 }
2601                         } else {
2602                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2603                         }
2604                         in_signal_flow = true;
2605                 } else {
2606                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2607                 }
2608
2609                 if (!in_signal_flow) {
2610                         uninvolved.push_back (*i);
2611                 }
2612         }
2613
2614         solo_update_disabled = false;
2615         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2616
2617         update_route_solo_state (r);
2618
2619         /* now notify that the mute state of the routes not involved in the signal
2620            pathway of the just-solo-changed route may have altered.
2621         */
2622
2623         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2624                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2625                 (*i)->mute_changed (this);
2626         }
2627
2628         SoloChanged (); /* EMIT SIGNAL */
2629         set_dirty();
2630 }
2631
2632 void
2633 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2634 {
2635         /* now figure out if anything that matters is soloed (or is "listening")*/
2636
2637         bool something_soloed = false;
2638         uint32_t listeners = 0;
2639         uint32_t isolated = 0;
2640
2641         if (!r) {
2642                 r = routes.reader();
2643         }
2644
2645         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2646                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2647                         something_soloed = true;
2648                 }
2649
2650                 if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
2651                         if (Config->get_solo_control_is_listen_control()) {
2652                                 listeners++;
2653                         } else {
2654                                 (*i)->set_listen (false, this);
2655                         }
2656                 }
2657
2658                 if ((*i)->solo_isolated()) {
2659                         isolated++;
2660                 }
2661         }
2662
2663         if (something_soloed != _non_soloed_outs_muted) {
2664                 _non_soloed_outs_muted = something_soloed;
2665                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2666         }
2667
2668         _listen_cnt = listeners;
2669
2670         if (isolated != _solo_isolated_cnt) {
2671                 _solo_isolated_cnt = isolated;
2672                 IsolatedChanged (); /* EMIT SIGNAL */
2673         }
2674
2675         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2676                                                   something_soloed, listeners, isolated));
2677 }
2678
2679 boost::shared_ptr<RouteList>
2680 Session::get_routes_with_internal_returns() const
2681 {
2682         boost::shared_ptr<RouteList> r = routes.reader ();
2683         boost::shared_ptr<RouteList> rl (new RouteList);
2684
2685         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2686                 if ((*i)->internal_return ()) {
2687                         rl->push_back (*i);
2688                 }
2689         }
2690         return rl;
2691 }
2692
2693 bool
2694 Session::io_name_is_legal (const std::string& name)
2695 {
2696         boost::shared_ptr<RouteList> r = routes.reader ();
2697
2698         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2699                 if ((*i)->name() == name) {
2700                         return false;
2701                 }
2702
2703                 if ((*i)->has_io_processor_named (name)) {
2704                         return false;
2705                 }
2706         }
2707
2708         return true;
2709 }
2710
2711 void
2712 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2713 {
2714         RouteList rl2;
2715         vector<string> connections;
2716
2717         /* if we are passed only a single route and we're not told to turn
2718          * others off, then just do the simple thing.
2719          */
2720
2721         if (flip_others == false && rl->size() == 1) {
2722                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2723                 if (mt) {
2724                         mt->set_input_active (onoff);
2725                         return;
2726                 }
2727         }
2728
2729         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2730
2731                 PortSet& ps ((*rt)->input()->ports());
2732
2733                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2734                         p->get_connections (connections);
2735                 }
2736
2737                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2738                         routes_using_input_from (*s, rl2);
2739                 }
2740
2741                 /* scan all relevant routes to see if others are on or off */
2742
2743                 bool others_are_already_on = false;
2744
2745                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2746
2747                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2748
2749                         if (!mt) {
2750                                 continue;
2751                         }
2752
2753                         if ((*r) != (*rt)) {
2754                                 if (mt->input_active()) {
2755                                         others_are_already_on = true;
2756                                 }
2757                         } else {
2758                                 /* this one needs changing */
2759                                 mt->set_input_active (onoff);
2760                         }
2761                 }
2762
2763                 if (flip_others) {
2764
2765                         /* globally reverse other routes */
2766
2767                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2768                                 if ((*r) != (*rt)) {
2769                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2770                                         if (mt) {
2771                                                 mt->set_input_active (!others_are_already_on);
2772                                         }
2773                                 }
2774                         }
2775                 }
2776         }
2777 }
2778
2779 void
2780 Session::routes_using_input_from (const string& str, RouteList& rl)
2781 {
2782         boost::shared_ptr<RouteList> r = routes.reader();
2783
2784         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2785                 if ((*i)->input()->connected_to (str)) {
2786                         rl.push_back (*i);
2787                 }
2788         }
2789 }
2790
2791 boost::shared_ptr<Route>
2792 Session::route_by_name (string name)
2793 {
2794         boost::shared_ptr<RouteList> r = routes.reader ();
2795
2796         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2797                 if ((*i)->name() == name) {
2798                         return *i;
2799                 }
2800         }
2801
2802         return boost::shared_ptr<Route> ((Route*) 0);
2803 }
2804
2805 boost::shared_ptr<Route>
2806 Session::route_by_id (PBD::ID id)
2807 {
2808         boost::shared_ptr<RouteList> r = routes.reader ();
2809
2810         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2811                 if ((*i)->id() == id) {
2812                         return *i;
2813                 }
2814         }
2815
2816         return boost::shared_ptr<Route> ((Route*) 0);
2817 }
2818
2819 boost::shared_ptr<Track>
2820 Session::track_by_diskstream_id (PBD::ID id)
2821 {
2822         boost::shared_ptr<RouteList> r = routes.reader ();
2823
2824         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2825                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
2826                 if (t && t->using_diskstream_id (id)) {
2827                         return t;
2828                 }
2829         }
2830
2831         return boost::shared_ptr<Track> ();
2832 }
2833
2834 boost::shared_ptr<Route>
2835 Session::route_by_remote_id (uint32_t id)
2836 {
2837         boost::shared_ptr<RouteList> r = routes.reader ();
2838
2839         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2840                 if ((*i)->remote_control_id() == id) {
2841                         return *i;
2842                 }
2843         }
2844
2845         return boost::shared_ptr<Route> ((Route*) 0);
2846 }
2847
2848 void
2849 Session::playlist_region_added (boost::weak_ptr<Region> w)
2850 {
2851         boost::shared_ptr<Region> r = w.lock ();
2852         if (!r) {
2853                 return;
2854         }
2855
2856         /* These are the operations that are currently in progress... */
2857         list<GQuark> curr = _current_trans_quarks;
2858         curr.sort ();
2859
2860         /* ...and these are the operations during which we want to update
2861            the session range location markers.
2862         */
2863         list<GQuark> ops;
2864         ops.push_back (Operations::capture);
2865         ops.push_back (Operations::paste);
2866         ops.push_back (Operations::duplicate_region);
2867         ops.push_back (Operations::insert_file);
2868         ops.push_back (Operations::insert_region);
2869         ops.push_back (Operations::drag_region_brush);
2870         ops.push_back (Operations::region_drag);
2871         ops.push_back (Operations::selection_grab);
2872         ops.push_back (Operations::region_fill);
2873         ops.push_back (Operations::fill_selection);
2874         ops.push_back (Operations::create_region);
2875         ops.push_back (Operations::region_copy);
2876         ops.push_back (Operations::fixed_time_region_copy);
2877         ops.sort ();
2878
2879         /* See if any of the current operations match the ones that we want */
2880         list<GQuark> in;
2881         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2882
2883         /* If so, update the session range markers */
2884         if (!in.empty ()) {
2885                 maybe_update_session_range (r->position (), r->last_frame ());
2886         }
2887 }
2888
2889 /** Update the session range markers if a is before the current start or
2890  *  b is after the current end.
2891  */
2892 void
2893 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2894 {
2895         if (_state_of_the_state & Loading) {
2896                 return;
2897         }
2898
2899         if (_session_range_location == 0) {
2900
2901                 add_session_range_location (a, b);
2902
2903         } else {
2904
2905                 if (a < _session_range_location->start()) {
2906                         _session_range_location->set_start (a);
2907                 }
2908
2909                 if (b > _session_range_location->end()) {
2910                         _session_range_location->set_end (b);
2911                 }
2912         }
2913 }
2914
2915 void
2916 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2917 {
2918         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2919                 maybe_update_session_range (i->to, i->to + i->length);
2920         }
2921 }
2922
2923 void
2924 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2925 {
2926         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2927                 maybe_update_session_range (i->from, i->to);
2928         }
2929 }
2930
2931 /* Region management */
2932
2933 boost::shared_ptr<Region>
2934 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2935 {
2936         const RegionFactory::RegionMap& regions (RegionFactory::regions());
2937         RegionFactory::RegionMap::const_iterator i;
2938         boost::shared_ptr<Region> region;
2939
2940         Glib::Threads::Mutex::Lock lm (region_lock);
2941
2942         for (i = regions.begin(); i != regions.end(); ++i) {
2943
2944                 region = i->second;
2945
2946                 if (region->whole_file()) {
2947
2948                         if (child->source_equivalent (region)) {
2949                                 return region;
2950                         }
2951                 }
2952         }
2953
2954         return boost::shared_ptr<Region> ();
2955 }
2956
2957 int
2958 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2959 {
2960         set<boost::shared_ptr<Region> > relevant_regions;
2961
2962         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2963                 RegionFactory::get_regions_using_source (*s, relevant_regions);
2964         }
2965
2966         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2967                 set<boost::shared_ptr<Region> >::iterator tmp;
2968
2969                 tmp = r;
2970                 ++tmp;
2971
2972                 playlists->destroy_region (*r);
2973                 RegionFactory::map_remove (*r);
2974
2975                 (*r)->drop_sources ();
2976                 (*r)->drop_references ();
2977
2978                 relevant_regions.erase (r);
2979
2980                 r = tmp;
2981         }
2982
2983         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2984
2985                 {
2986                         Glib::Threads::Mutex::Lock ls (source_lock);
2987                         /* remove from the main source list */
2988                         sources.erase ((*s)->id());
2989                 }
2990
2991                 (*s)->mark_for_remove ();
2992                 (*s)->drop_references ();
2993
2994                 s = srcs.erase (s);
2995         }
2996
2997         return 0;
2998 }
2999
3000 int
3001 Session::remove_last_capture ()
3002 {
3003         list<boost::shared_ptr<Source> > srcs;
3004
3005         boost::shared_ptr<RouteList> rl = routes.reader ();
3006         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3007                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3008                 if (!tr) {
3009                         continue;
3010                 }
3011
3012                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3013
3014                 if (!l.empty()) {
3015                         srcs.insert (srcs.end(), l.begin(), l.end());
3016                         l.clear ();
3017                 }
3018         }
3019
3020         destroy_sources (srcs);
3021
3022         save_state (_current_snapshot_name);
3023
3024         return 0;
3025 }
3026
3027 /* Source Management */
3028
3029 void
3030 Session::add_source (boost::shared_ptr<Source> source)
3031 {
3032         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3033         pair<SourceMap::iterator,bool> result;
3034
3035         entry.first = source->id();
3036         entry.second = source;
3037
3038         {
3039                 Glib::Threads::Mutex::Lock lm (source_lock);
3040                 result = sources.insert (entry);
3041         }
3042
3043         if (result.second) {
3044
3045                 /* yay, new source */
3046
3047                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3048
3049                 if (fs) {
3050                         if (!fs->within_session()) {
3051                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3052                         }
3053                 }
3054
3055                 set_dirty();
3056
3057                 boost::shared_ptr<AudioFileSource> afs;
3058
3059                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3060                         if (Config->get_auto_analyse_audio()) {
3061                                 Analyser::queue_source_for_analysis (source, false);
3062                         }
3063                 }
3064
3065                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3066         }
3067 }
3068
3069 void
3070 Session::remove_source (boost::weak_ptr<Source> src)
3071 {
3072         if (_state_of_the_state & Deletion) {
3073                 return;
3074         }
3075
3076         SourceMap::iterator i;
3077         boost::shared_ptr<Source> source = src.lock();
3078
3079         if (!source) {
3080                 return;
3081         }
3082
3083         {
3084                 Glib::Threads::Mutex::Lock lm (source_lock);
3085
3086                 if ((i = sources.find (source->id())) != sources.end()) {
3087                         sources.erase (i);
3088                 }
3089         }
3090
3091         if (!(_state_of_the_state & InCleanup)) {
3092
3093                 /* save state so we don't end up with a session file
3094                    referring to non-existent sources.
3095                 */
3096
3097                 save_state (_current_snapshot_name);
3098         }
3099 }
3100
3101 boost::shared_ptr<Source>
3102 Session::source_by_id (const PBD::ID& id)
3103 {
3104         Glib::Threads::Mutex::Lock lm (source_lock);
3105         SourceMap::iterator i;
3106         boost::shared_ptr<Source> source;
3107
3108         if ((i = sources.find (id)) != sources.end()) {
3109                 source = i->second;
3110         }
3111
3112         return source;
3113 }
3114
3115 boost::shared_ptr<Source>
3116 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3117 {
3118         Glib::Threads::Mutex::Lock lm (source_lock);
3119
3120         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3121                 boost::shared_ptr<AudioFileSource> afs
3122                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3123
3124                 if (afs && afs->path() == path && chn == afs->channel()) {
3125                         return afs;
3126                 }
3127         }
3128         return boost::shared_ptr<Source>();
3129 }
3130
3131 uint32_t
3132 Session::count_sources_by_origin (const string& path)
3133 {
3134         uint32_t cnt = 0;
3135         Glib::Threads::Mutex::Lock lm (source_lock);
3136
3137         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3138                 boost::shared_ptr<FileSource> fs
3139                         = boost::dynamic_pointer_cast<FileSource>(i->second);
3140
3141                 if (fs && fs->origin() == path) {
3142                         ++cnt;
3143                 }
3144         }
3145
3146         return cnt;
3147 }
3148
3149
3150 string
3151 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3152 {
3153         string look_for;
3154         string old_basename = PBD::basename_nosuffix (oldname);
3155         string new_legalized = legalize_for_path (newname);
3156
3157         /* note: we know (or assume) the old path is already valid */
3158
3159         if (destructive) {
3160
3161                 /* destructive file sources have a name of the form:
3162
3163                     /path/to/Tnnnn-NAME(%[LR])?.wav
3164
3165                     the task here is to replace NAME with the new name.
3166                 */
3167
3168                 string dir;
3169                 string prefix;
3170                 string::size_type dash;
3171
3172                 dir = Glib::path_get_dirname (path);
3173                 path = Glib::path_get_basename (path);
3174
3175                 /* '-' is not a legal character for the NAME part of the path */
3176
3177                 if ((dash = path.find_last_of ('-')) == string::npos) {
3178                         return "";
3179                 }
3180
3181                 prefix = path.substr (0, dash);
3182
3183                 path += prefix;
3184                 path += '-';
3185                 path += new_legalized;
3186                 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3187                 path = Glib::build_filename (dir, path);
3188
3189         } else {
3190
3191                 /* non-destructive file sources have a name of the form:
3192
3193                     /path/to/NAME-nnnnn(%[LR])?.ext
3194
3195                     the task here is to replace NAME with the new name.
3196                 */
3197
3198                 string dir;
3199                 string suffix;
3200                 string::size_type dash;
3201                 string::size_type postfix;
3202
3203                 dir = Glib::path_get_dirname (path);
3204                 path = Glib::path_get_basename (path);
3205
3206                 /* '-' is not a legal character for the NAME part of the path */
3207
3208                 if ((dash = path.find_last_of ('-')) == string::npos) {
3209                         return "";
3210                 }
3211
3212                 suffix = path.substr (dash+1);
3213
3214                 // Suffix is now everything after the dash. Now we need to eliminate
3215                 // the nnnnn part, which is done by either finding a '%' or a '.'
3216
3217                 postfix = suffix.find_last_of ("%");
3218                 if (postfix == string::npos) {
3219                         postfix = suffix.find_last_of ('.');
3220                 }
3221
3222                 if (postfix != string::npos) {
3223                         suffix = suffix.substr (postfix);
3224                 } else {
3225                         error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3226                         return "";
3227                 }
3228
3229                 const uint32_t limit = 10000;
3230                 char buf[PATH_MAX+1];
3231
3232                 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3233
3234                         snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3235
3236                         if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3237                                 path = Glib::build_filename (dir, buf);
3238                                 break;
3239                         }
3240
3241                         path = "";
3242                 }
3243
3244                 if (path.empty()) {
3245                         fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3246                                                  newname) << endl;
3247                         /*NOTREACHED*/
3248                 }
3249         }
3250
3251         return path;
3252 }
3253
3254 /** Return the full path (in some session directory) for a new within-session source.
3255  * \a name must be a session-unique name that does not contain slashes
3256  *         (e.g. as returned by new_*_source_name)
3257  */
3258 string
3259 Session::new_source_path_from_name (DataType type, const string& name)
3260 {
3261         assert(name.find("/") == string::npos);
3262
3263         SessionDirectory sdir(get_best_session_directory_for_new_source());
3264
3265         std::string p;
3266         if (type == DataType::AUDIO) {
3267                 p = sdir.sound_path();
3268         } else if (type == DataType::MIDI) {
3269                 p = sdir.midi_path();
3270         } else {
3271                 error << "Unknown source type, unable to create file path" << endmsg;
3272                 return "";
3273         }
3274
3275         return Glib::build_filename (p, name);
3276 }
3277
3278 string
3279 Session::peak_path (string base) const
3280 {
3281         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3282 }
3283
3284 /** Return a unique name based on \a base for a new internal audio source */
3285 string
3286 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3287 {
3288         uint32_t cnt;
3289         char buf[PATH_MAX+1];
3290         const uint32_t limit = 10000;
3291         string legalized;
3292         string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3293
3294         buf[0] = '\0';
3295         legalized = legalize_for_path (base);
3296
3297         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3298         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3299
3300                 vector<space_and_path>::iterator i;
3301                 uint32_t existing = 0;
3302
3303                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3304
3305                         if (destructive) {
3306
3307                                 if (nchan < 2) {
3308                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3309                                                   cnt, legalized.c_str(), ext.c_str());
3310                                 } else if (nchan == 2) {
3311                                         if (chan == 0) {
3312                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3313                                                           cnt, legalized.c_str(), ext.c_str());
3314                                         } else {
3315                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3316                                                           cnt, legalized.c_str(), ext.c_str());
3317                                         }
3318                                 } else if (nchan < 26) {
3319                                         snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3320                                                   cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3321                                 } else {
3322                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3323                                                   cnt, legalized.c_str(), ext.c_str());
3324                                 }
3325
3326                         } else {
3327
3328                                 if (nchan < 2) {
3329                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3330                                 } else if (nchan == 2) {
3331                                         if (chan == 0) {
3332                                                 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3333                                         } else {
3334                                                 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3335                                         }
3336                                 } else if (nchan < 26) {
3337                                         snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3338                                 } else {
3339                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3340                                 }
3341                         }
3342
3343                         SessionDirectory sdir((*i).path);
3344
3345                         string spath = sdir.sound_path();
3346
3347                         /* note that we search *without* the extension so that
3348                            we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3349                            in the event that this new name is required for
3350                            a file format change.
3351                         */
3352
3353                         if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3354                                 existing++;
3355                                 break;
3356                         }
3357                 }
3358
3359                 if (existing == 0) {
3360                         break;
3361                 }
3362
3363                 if (cnt > limit) {
3364                         error << string_compose(
3365                                         _("There are already %1 recordings for %2, which I consider too many."),
3366                                         limit, base) << endmsg;
3367                         destroy ();
3368                         throw failed_constructor();
3369                 }
3370         }
3371
3372         return Glib::path_get_basename (buf);
3373 }
3374
3375 /** Create a new within-session audio source */
3376 boost::shared_ptr<AudioFileSource>
3377 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3378 {
3379         const string name    = new_audio_source_name (n, n_chans, chan, destructive);
3380         const string path    = new_source_path_from_name(DataType::AUDIO, name);
3381
3382         return boost::dynamic_pointer_cast<AudioFileSource> (
3383                 SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
3384 }
3385
3386 /** Return a unique name based on \a base for a new internal MIDI source */
3387 string
3388 Session::new_midi_source_name (const string& base)
3389 {
3390         uint32_t cnt;
3391         char buf[PATH_MAX+1];
3392         const uint32_t limit = 10000;
3393         string legalized;
3394
3395         buf[0] = '\0';
3396         legalized = legalize_for_path (base);
3397
3398         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3399         for (cnt = 1; cnt <= limit; ++cnt) {
3400
3401                 vector<space_and_path>::iterator i;
3402                 uint32_t existing = 0;
3403
3404                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3405
3406                         SessionDirectory sdir((*i).path);
3407
3408                         std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3409
3410                         snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3411
3412                         if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3413                                 existing++;
3414                         }
3415                 }
3416
3417                 if (existing == 0) {
3418                         break;
3419                 }
3420
3421                 if (cnt > limit) {
3422                         error << string_compose(
3423                                         _("There are already %1 recordings for %2, which I consider too many."),
3424                                         limit, base) << endmsg;
3425                         destroy ();
3426                         throw failed_constructor();
3427                 }
3428         }
3429
3430         return Glib::path_get_basename(buf);
3431 }
3432
3433
3434 /** Create a new within-session MIDI source */
3435 boost::shared_ptr<MidiSource>
3436 Session::create_midi_source_for_session (Track* track, string const & n)
3437 {
3438         /* try to use the existing write source for the track, to keep numbering sane
3439          */
3440
3441         if (track) {
3442                 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3443                   assert (mt);
3444                 */
3445
3446                 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3447
3448                 if (!l.empty()) {
3449                         assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3450                         return boost::dynamic_pointer_cast<MidiSource> (l.front());
3451                 }
3452         }
3453
3454         const string name = new_midi_source_name (n);
3455         const string path = new_source_path_from_name (DataType::MIDI, name);
3456
3457         return boost::dynamic_pointer_cast<SMFSource> (
3458                 SourceFactory::createWritable (
3459                         DataType::MIDI, *this, path, string(), false, frame_rate()));
3460 }
3461
3462
3463 void
3464 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3465 {
3466         if (playlist->hidden()) {
3467                 return;
3468         }
3469
3470         playlists->add (playlist);
3471
3472         if (unused) {
3473                 playlist->release();
3474         }
3475
3476         set_dirty();
3477 }
3478
3479 void
3480 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3481 {
3482         if (_state_of_the_state & Deletion) {
3483                 return;
3484         }
3485
3486         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3487
3488         if (!playlist) {
3489                 return;
3490         }
3491
3492         playlists->remove (playlist);
3493
3494         set_dirty();
3495 }
3496
3497 void
3498 Session::set_audition (boost::shared_ptr<Region> r)
3499 {
3500         pending_audition_region = r;
3501         add_post_transport_work (PostTransportAudition);
3502         _butler->schedule_transport_work ();
3503 }
3504
3505 void
3506 Session::audition_playlist ()
3507 {
3508         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3509         ev->region.reset ();
3510         queue_event (ev);
3511 }
3512
3513 void
3514 Session::non_realtime_set_audition ()
3515 {
3516         assert (pending_audition_region);
3517         auditioner->audition_region (pending_audition_region);
3518         pending_audition_region.reset ();
3519         AuditionActive (true); /* EMIT SIGNAL */
3520 }
3521
3522 void
3523 Session::audition_region (boost::shared_ptr<Region> r)
3524 {
3525         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3526         ev->region = r;
3527         queue_event (ev);
3528 }
3529
3530 void
3531 Session::cancel_audition ()
3532 {
3533         if (auditioner->auditioning()) {
3534                 auditioner->cancel_audition ();
3535                 AuditionActive (false); /* EMIT SIGNAL */
3536         }
3537 }
3538
3539 bool
3540 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3541 {
3542         if (a->is_monitor()) {
3543                 return true;
3544         }
3545         if (b->is_monitor()) {
3546                 return false;
3547         }
3548         return a->order_key (MixerSort) < b->order_key (MixerSort);
3549 }
3550
3551 bool
3552 Session::is_auditioning () const
3553 {
3554         /* can be called before we have an auditioner object */
3555         if (auditioner) {
3556                 return auditioner->auditioning();
3557         } else {
3558                 return false;
3559         }
3560 }
3561
3562 void
3563 Session::graph_reordered ()
3564 {
3565         /* don't do this stuff if we are setting up connections
3566            from a set_state() call or creating new tracks. Ditto for deletion.
3567         */
3568
3569         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3570                 return;
3571         }
3572
3573         /* every track/bus asked for this to be handled but it was deferred because
3574            we were connecting. do it now.
3575         */
3576
3577         request_input_change_handling ();
3578
3579         resort_routes ();
3580
3581         /* force all diskstreams to update their capture offset values to
3582            reflect any changes in latencies within the graph.
3583         */
3584
3585         boost::shared_ptr<RouteList> rl = routes.reader ();
3586         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3587                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3588                 if (tr) {
3589                         tr->set_capture_offset ();
3590                 }
3591         }
3592 }
3593
3594 /** @return Number of frames that there is disk space available to write,
3595  *  if known.
3596  */
3597 boost::optional<framecnt_t>
3598 Session::available_capture_duration ()
3599 {
3600         Glib::Threads::Mutex::Lock lm (space_lock);
3601
3602         if (_total_free_4k_blocks_uncertain) {
3603                 return boost::optional<framecnt_t> ();
3604         }
3605
3606         float sample_bytes_on_disk = 4.0; // keep gcc happy
3607
3608         switch (config.get_native_file_data_format()) {
3609         case FormatFloat:
3610                 sample_bytes_on_disk = 4.0;
3611                 break;
3612
3613         case FormatInt24:
3614                 sample_bytes_on_disk = 3.0;
3615                 break;
3616
3617         case FormatInt16:
3618                 sample_bytes_on_disk = 2.0;
3619                 break;
3620
3621         default:
3622                 /* impossible, but keep some gcc versions happy */
3623                 fatal << string_compose (_("programming error: %1"),
3624                                          X_("illegal native file data format"))
3625                       << endmsg;
3626                 /*NOTREACHED*/
3627         }
3628
3629         double scale = 4096.0 / sample_bytes_on_disk;
3630
3631         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3632                 return max_framecnt;
3633         }
3634
3635         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3636 }
3637
3638 void
3639 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3640 {
3641         {
3642                 RCUWriter<BundleList> writer (_bundles);
3643                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3644                 b->push_back (bundle);
3645         }
3646
3647         BundleAdded (bundle); /* EMIT SIGNAL */
3648
3649         set_dirty();
3650 }
3651
3652 void
3653 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3654 {
3655         bool removed = false;
3656
3657         {
3658                 RCUWriter<BundleList> writer (_bundles);
3659                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3660                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3661
3662                 if (i != b->end()) {
3663                         b->erase (i);
3664                         removed = true;
3665                 }
3666         }
3667
3668         if (removed) {
3669                  BundleRemoved (bundle); /* EMIT SIGNAL */
3670         }
3671
3672         set_dirty();
3673 }
3674
3675 boost::shared_ptr<Bundle>
3676 Session::bundle_by_name (string name) const
3677 {
3678         boost::shared_ptr<BundleList> b = _bundles.reader ();
3679
3680         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3681                 if ((*i)->name() == name) {
3682                         return* i;
3683                 }
3684         }
3685
3686         return boost::shared_ptr<Bundle> ();
3687 }
3688
3689 void
3690 Session::tempo_map_changed (const PropertyChange&)
3691 {
3692         clear_clicks ();
3693
3694         playlists->update_after_tempo_map_change ();
3695
3696         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3697
3698         set_dirty ();
3699 }
3700
3701 void
3702 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3703 {
3704         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3705                 (*i)->recompute_frames_from_bbt ();
3706         }
3707 }
3708
3709 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3710  * the given count with the current block size.
3711  */
3712 void
3713 Session::ensure_buffers (ChanCount howmany)
3714 {
3715         BufferManager::ensure_buffers (howmany);
3716 }
3717
3718 void
3719 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3720 {
3721         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3722                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3723         }
3724 }
3725
3726 uint32_t
3727 Session::next_insert_id ()
3728 {
3729         /* this doesn't really loop forever. just think about it */
3730
3731         while (true) {
3732                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3733                         if (!insert_bitset[n]) {
3734                                 insert_bitset[n] = true;
3735                                 return n;
3736
3737                         }
3738                 }
3739
3740                 /* none available, so resize and try again */
3741
3742                 insert_bitset.resize (insert_bitset.size() + 16, false);
3743         }
3744 }
3745
3746 uint32_t
3747 Session::next_send_id ()
3748 {
3749         /* this doesn't really loop forever. just think about it */
3750
3751         while (true) {
3752                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3753                         if (!send_bitset[n]) {
3754                                 send_bitset[n] = true;
3755                                 return n;
3756
3757                         }
3758                 }
3759
3760                 /* none available, so resize and try again */
3761
3762                 send_bitset.resize (send_bitset.size() + 16, false);
3763         }
3764 }
3765
3766 uint32_t
3767 Session::next_aux_send_id ()
3768 {
3769         /* this doesn't really loop forever. just think about it */
3770
3771         while (true) {
3772                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3773                         if (!aux_send_bitset[n]) {
3774                                 aux_send_bitset[n] = true;
3775                                 return n;
3776
3777                         }
3778                 }
3779
3780                 /* none available, so resize and try again */
3781
3782                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3783         }
3784 }
3785
3786 uint32_t
3787 Session::next_return_id ()
3788 {
3789         /* this doesn't really loop forever. just think about it */
3790
3791         while (true) {
3792                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3793                         if (!return_bitset[n]) {
3794                                 return_bitset[n] = true;
3795                                 return n;
3796
3797                         }
3798                 }
3799
3800                 /* none available, so resize and try again */
3801
3802                 return_bitset.resize (return_bitset.size() + 16, false);
3803         }
3804 }
3805
3806 void
3807 Session::mark_send_id (uint32_t id)
3808 {
3809         if (id >= send_bitset.size()) {
3810                 send_bitset.resize (id+16, false);
3811         }
3812         if (send_bitset[id]) {
3813                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3814         }
3815         send_bitset[id] = true;
3816 }
3817
3818 void
3819 Session::mark_aux_send_id (uint32_t id)
3820 {
3821         if (id >= aux_send_bitset.size()) {
3822                 aux_send_bitset.resize (id+16, false);
3823         }
3824         if (aux_send_bitset[id]) {
3825                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3826         }
3827         aux_send_bitset[id] = true;
3828 }
3829
3830 void
3831 Session::mark_return_id (uint32_t id)
3832 {
3833         if (id >= return_bitset.size()) {
3834                 return_bitset.resize (id+16, false);
3835         }
3836         if (return_bitset[id]) {
3837                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3838         }
3839         return_bitset[id] = true;
3840 }
3841
3842 void
3843 Session::mark_insert_id (uint32_t id)
3844 {
3845         if (id >= insert_bitset.size()) {
3846                 insert_bitset.resize (id+16, false);
3847         }
3848         if (insert_bitset[id]) {
3849                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3850         }
3851         insert_bitset[id] = true;
3852 }
3853
3854 void
3855 Session::unmark_send_id (uint32_t id)
3856 {
3857         if (id < send_bitset.size()) {
3858                 send_bitset[id] = false;
3859         }
3860 }
3861
3862 void
3863 Session::unmark_aux_send_id (uint32_t id)
3864 {
3865         if (id < aux_send_bitset.size()) {
3866                 aux_send_bitset[id] = false;
3867         }
3868 }
3869
3870 void
3871 Session::unmark_return_id (uint32_t id)
3872 {
3873         if (id < return_bitset.size()) {
3874                 return_bitset[id] = false;
3875         }
3876 }
3877
3878 void
3879 Session::unmark_insert_id (uint32_t id)
3880 {
3881         if (id < insert_bitset.size()) {
3882                 insert_bitset[id] = false;
3883         }
3884 }
3885
3886 void
3887 Session::reset_native_file_format ()
3888 {
3889         boost::shared_ptr<RouteList> rl = routes.reader ();
3890         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3891                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3892                 if (tr) {
3893                         /* don't save state as we do this, there's no point
3894                          */
3895
3896                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3897                         tr->reset_write_sources (false);
3898                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3899                 }
3900         }
3901 }
3902
3903 bool
3904 Session::route_name_unique (string n) const
3905 {
3906         boost::shared_ptr<RouteList> r = routes.reader ();
3907
3908         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3909                 if ((*i)->name() == n) {
3910                         return false;
3911                 }
3912         }
3913
3914         return true;
3915 }
3916
3917 bool
3918 Session::route_name_internal (string n) const
3919 {
3920         if (auditioner && auditioner->name() == n) {
3921                 return true;
3922         }
3923
3924         if (_click_io && _click_io->name() == n) {
3925                 return true;
3926         }
3927
3928         return false;
3929 }
3930
3931 int
3932 Session::freeze_all (InterThreadInfo& itt)
3933 {
3934         boost::shared_ptr<RouteList> r = routes.reader ();
3935
3936         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3937
3938                 boost::shared_ptr<Track> t;
3939
3940                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3941                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3942                            of every track.
3943                         */
3944                         t->freeze_me (itt);
3945                 }
3946         }
3947
3948         return 0;
3949 }
3950
3951 boost::shared_ptr<Region>
3952 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3953                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3954                           InterThreadInfo& itt,
3955                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
3956                           bool for_export)
3957 {
3958         boost::shared_ptr<Region> result;
3959         boost::shared_ptr<Playlist> playlist;
3960         boost::shared_ptr<AudioFileSource> fsource;
3961         uint32_t x;
3962         char buf[PATH_MAX+1];
3963         ChanCount diskstream_channels (track.n_channels());
3964         framepos_t position;
3965         framecnt_t this_chunk;
3966         framepos_t to_do;
3967         BufferSet buffers;
3968         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3969         const string sound_dir = sdir.sound_path();
3970         framepos_t len = end - start;
3971         bool need_block_size_reset = false;
3972         string ext;
3973         ChanCount const max_proc = track.max_processor_streams ();
3974
3975         if (end <= start) {
3976                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3977                                          end, start) << endmsg;
3978                 return result;
3979         }
3980
3981         const framecnt_t chunk_size = (256 * 1024)/4;
3982
3983         // block all process callback handling
3984
3985         block_processing ();
3986
3987         /* call tree *MUST* hold route_lock */
3988
3989         if ((playlist = track.playlist()) == 0) {
3990                 goto out;
3991         }
3992
3993         ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3994
3995         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3996
3997                 for (x = 0; x < 99999; ++x) {
3998                         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());
3999                         if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
4000                                 break;
4001                         }
4002                 }
4003
4004                 if (x == 99999) {
4005                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4006                         goto out;
4007                 }
4008
4009                 try {
4010                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4011                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
4012                 }
4013
4014                 catch (failed_constructor& err) {
4015                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4016                         goto out;
4017                 }
4018
4019                 srcs.push_back (fsource);
4020         }
4021
4022         /* tell redirects that care that we are about to use a much larger
4023          * blocksize. this will flush all plugins too, so that they are ready
4024          * to be used for this process.
4025          */
4026
4027         need_block_size_reset = true;
4028         track.set_block_size (chunk_size);
4029
4030         position = start;
4031         to_do = len;
4032
4033         /* create a set of reasonably-sized buffers */
4034         buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4035         buffers.set_count (max_proc);
4036
4037         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4038                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4039                 if (afs)
4040                         afs->prepare_for_peakfile_writes ();
4041         }
4042
4043         while (to_do && !itt.cancel) {
4044
4045                 this_chunk = min (to_do, chunk_size);
4046
4047                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4048                         goto out;
4049                 }
4050
4051                 uint32_t n = 0;
4052                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4053                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4054
4055                         if (afs) {
4056                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4057                                         goto out;
4058                                 }
4059                         }
4060                 }
4061
4062                 start += this_chunk;
4063                 to_do -= this_chunk;
4064
4065                 itt.progress = (float) (1.0 - ((double) to_do / len));
4066
4067         }
4068
4069         if (!itt.cancel) {
4070
4071                 time_t now;
4072                 struct tm* xnow;
4073                 time (&now);
4074                 xnow = localtime (&now);
4075
4076                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4077                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4078
4079                         if (afs) {
4080                                 afs->update_header (position, *xnow, now);
4081                                 afs->flush_header ();
4082                         }
4083                 }
4084
4085                 /* construct a region to represent the bounced material */
4086
4087                 PropertyList plist;
4088
4089                 plist.add (Properties::start, 0);
4090                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4091                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4092
4093                 result = RegionFactory::create (srcs, plist);
4094
4095         }
4096
4097   out:
4098         if (!result) {
4099                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4100                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4101
4102                         if (afs) {
4103                                 afs->mark_for_remove ();
4104                         }
4105
4106                         (*src)->drop_references ();
4107                 }
4108
4109         } else {
4110                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4111                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4112
4113                         if (afs)
4114                                 afs->done_with_peakfile_writes ();
4115                 }
4116         }
4117
4118
4119         if (need_block_size_reset) {
4120                 track.set_block_size (get_block_size());
4121         }
4122
4123         unblock_processing ();
4124
4125         return result;
4126 }
4127
4128 gain_t*
4129 Session::gain_automation_buffer() const
4130 {
4131         return ProcessThread::gain_automation_buffer ();
4132 }
4133
4134 gain_t*
4135 Session::send_gain_automation_buffer() const
4136 {
4137         return ProcessThread::send_gain_automation_buffer ();
4138 }
4139
4140 pan_t**
4141 Session::pan_automation_buffer() const
4142 {
4143         return ProcessThread::pan_automation_buffer ();
4144 }
4145
4146 BufferSet&
4147 Session::get_silent_buffers (ChanCount count)
4148 {
4149         return ProcessThread::get_silent_buffers (count);
4150 }
4151
4152 BufferSet&
4153 Session::get_scratch_buffers (ChanCount count)
4154 {
4155         return ProcessThread::get_scratch_buffers (count);
4156 }
4157
4158 BufferSet&
4159 Session::get_mix_buffers (ChanCount count)
4160 {
4161         return ProcessThread::get_mix_buffers (count);
4162 }
4163
4164 uint32_t
4165 Session::ntracks () const
4166 {
4167         uint32_t n = 0;
4168         boost::shared_ptr<RouteList> r = routes.reader ();
4169
4170         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4171                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4172                         ++n;
4173                 }
4174         }
4175
4176         return n;
4177 }
4178
4179 uint32_t
4180 Session::nbusses () const
4181 {
4182         uint32_t n = 0;
4183         boost::shared_ptr<RouteList> r = routes.reader ();
4184
4185         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4186                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4187                         ++n;
4188                 }
4189         }
4190
4191         return n;
4192 }
4193
4194 void
4195 Session::add_automation_list(AutomationList *al)
4196 {
4197         automation_lists[al->id()] = al;
4198 }
4199
4200 /** @return true if there is at least one record-enabled track, otherwise false */
4201 bool
4202 Session::have_rec_enabled_track () const
4203 {
4204         return g_atomic_int_get (&_have_rec_enabled_track) == 1;
4205 }
4206
4207 /** Update the state of our rec-enabled tracks flag */
4208 void
4209 Session::update_have_rec_enabled_track ()
4210 {
4211         boost::shared_ptr<RouteList> rl = routes.reader ();
4212         RouteList::iterator i = rl->begin();
4213         while (i != rl->end ()) {
4214
4215                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4216                 if (tr && tr->record_enabled ()) {
4217                         break;
4218                 }
4219
4220                 ++i;
4221         }
4222
4223         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4224
4225         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4226
4227         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4228                 RecordStateChanged (); /* EMIT SIGNAL */
4229         }
4230 }
4231
4232 void
4233 Session::listen_position_changed ()
4234 {
4235         boost::shared_ptr<RouteList> r = routes.reader ();
4236
4237         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4238                 (*i)->listen_position_changed ();
4239         }
4240 }
4241
4242 void
4243 Session::solo_control_mode_changed ()
4244 {
4245         /* cancel all solo or all listen when solo control mode changes */
4246
4247         if (soloing()) {
4248                 set_solo (get_routes(), false);
4249         } else if (listening()) {
4250                 set_listen (get_routes(), false);
4251         }
4252 }
4253
4254 /** Called when a property of one of our route groups changes */
4255 void
4256 Session::route_group_property_changed (RouteGroup* rg)
4257 {
4258         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4259 }
4260
4261 /** Called when a route is added to one of our route groups */
4262 void
4263 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4264 {
4265         RouteAddedToRouteGroup (rg, r);
4266 }
4267
4268 /** Called when a route is removed from one of our route groups */
4269 void
4270 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4271 {
4272         RouteRemovedFromRouteGroup (rg, r);
4273 }
4274
4275 boost::shared_ptr<RouteList>
4276 Session::get_routes_with_regions_at (framepos_t const p) const
4277 {
4278         boost::shared_ptr<RouteList> r = routes.reader ();
4279         boost::shared_ptr<RouteList> rl (new RouteList);
4280
4281         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4282                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4283                 if (!tr) {
4284                         continue;
4285                 }
4286
4287                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4288                 if (!pl) {
4289                         continue;
4290                 }
4291
4292                 if (pl->has_region_at (p)) {
4293                         rl->push_back (*i);
4294                 }
4295         }
4296
4297         return rl;
4298 }
4299
4300 void
4301 Session::goto_end ()
4302 {
4303         if (_session_range_location) {
4304                 request_locate (_session_range_location->end(), false);
4305         } else {
4306                 request_locate (0, false);
4307         }
4308 }
4309
4310 void
4311 Session::goto_start ()
4312 {
4313         if (_session_range_location) {
4314                 request_locate (_session_range_location->start(), false);
4315         } else {
4316                 request_locate (0, false);
4317         }
4318 }
4319
4320 framepos_t
4321 Session::current_start_frame () const
4322 {
4323         return _session_range_location ? _session_range_location->start() : 0;
4324 }
4325
4326 framepos_t
4327 Session::current_end_frame () const
4328 {
4329         return _session_range_location ? _session_range_location->end() : 0;
4330 }
4331
4332 void
4333 Session::add_session_range_location (framepos_t start, framepos_t end)
4334 {
4335         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4336         _locations->add (_session_range_location);
4337 }
4338
4339 void
4340 Session::step_edit_status_change (bool yn)
4341 {
4342         bool send = false;
4343
4344         bool val = false;
4345         if (yn) {
4346                 send = (_step_editors == 0);
4347                 val = true;
4348
4349                 _step_editors++;
4350         } else {
4351                 send = (_step_editors == 1);
4352                 val = false;
4353
4354                 if (_step_editors > 0) {
4355                         _step_editors--;
4356                 }
4357         }
4358
4359         if (send) {
4360                 StepEditStatusChange (val);
4361         }
4362 }
4363
4364
4365 void
4366 Session::start_time_changed (framepos_t old)
4367 {
4368         /* Update the auto loop range to match the session range
4369            (unless the auto loop range has been changed by the user)
4370         */
4371
4372         Location* s = _locations->session_range_location ();
4373         if (s == 0) {
4374                 return;
4375         }
4376
4377         Location* l = _locations->auto_loop_location ();
4378
4379         if (l && l->start() == old) {
4380                 l->set_start (s->start(), true);
4381         }
4382 }
4383
4384 void
4385 Session::end_time_changed (framepos_t old)
4386 {
4387         /* Update the auto loop range to match the session range
4388            (unless the auto loop range has been changed by the user)
4389         */
4390
4391         Location* s = _locations->session_range_location ();
4392         if (s == 0) {
4393                 return;
4394         }
4395
4396         Location* l = _locations->auto_loop_location ();
4397
4398         if (l && l->end() == old) {
4399                 l->set_end (s->end(), true);
4400         }
4401 }
4402
4403 string
4404 Session::source_search_path (DataType type) const
4405 {
4406         vector<string> s;
4407
4408         if (session_dirs.size() == 1) {
4409                 switch (type) {
4410                 case DataType::AUDIO:
4411                         s.push_back (_session_dir->sound_path());
4412                         break;
4413                 case DataType::MIDI:
4414                         s.push_back (_session_dir->midi_path());
4415                         break;
4416                 }
4417         } else {
4418                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4419                         SessionDirectory sdir (i->path);
4420                         switch (type) {
4421                         case DataType::AUDIO:
4422                                 s.push_back (sdir.sound_path());
4423                                 break;
4424                         case DataType::MIDI:
4425                                 s.push_back (sdir.midi_path());
4426                                 break;
4427                         }
4428                 }
4429         }
4430
4431         if (type == DataType::AUDIO) {
4432                 const string sound_path_2X = _session_dir->sound_path_2X();
4433                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4434                         if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
4435                                 s.push_back (sound_path_2X);
4436                         }
4437                 }
4438         }
4439
4440         /* now check the explicit (possibly user-specified) search path
4441          */
4442
4443         vector<string> dirs;
4444
4445         switch (type) {
4446         case DataType::AUDIO:
4447                 split (config.get_audio_search_path (), dirs, ':');
4448                 break;
4449         case DataType::MIDI:
4450                 split (config.get_midi_search_path (), dirs, ':');
4451                 break;
4452         }
4453
4454         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4455                 if (find (s.begin(), s.end(), *i) == s.end()) {
4456                         s.push_back (*i);
4457                 }
4458         }
4459
4460         string search_path;
4461
4462         for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4463                 if (!search_path.empty()) {
4464                         search_path += ':';
4465                 }
4466                 search_path += *si;
4467         }
4468
4469         return search_path;
4470 }
4471
4472 void
4473 Session::ensure_search_path_includes (const string& path, DataType type)
4474 {
4475         string search_path;
4476         vector<string> dirs;
4477
4478         if (path == ".") {
4479                 return;
4480         }
4481
4482         switch (type) {
4483         case DataType::AUDIO:
4484                 search_path = config.get_audio_search_path ();
4485                 break;
4486         case DataType::MIDI:
4487                 search_path = config.get_midi_search_path ();
4488                 break;
4489         }
4490
4491         split (search_path, dirs, ':');
4492
4493         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4494                 /* No need to add this new directory if it has the same inode as
4495                    an existing one; checking inode rather than name prevents duplicated
4496                    directories when we are using symlinks.
4497
4498                    On Windows, I think we could just do if (*i == path) here.
4499                 */
4500                 if (PBD::equivalent_paths (*i, path)) {
4501                         return;
4502                 }
4503         }
4504
4505         if (!search_path.empty()) {
4506                 search_path += ':';
4507         }
4508
4509         search_path += path;
4510
4511         switch (type) {
4512         case DataType::AUDIO:
4513                 config.set_audio_search_path (search_path);
4514                 break;
4515         case DataType::MIDI:
4516                 config.set_midi_search_path (search_path);
4517                 break;
4518         }
4519 }
4520
4521 boost::shared_ptr<Speakers>
4522 Session::get_speakers()
4523 {
4524         return _speakers;
4525 }
4526
4527 list<string>
4528 Session::unknown_processors () const
4529 {
4530         list<string> p;
4531
4532         boost::shared_ptr<RouteList> r = routes.reader ();
4533         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4534                 list<string> t = (*i)->unknown_processors ();
4535                 copy (t.begin(), t.end(), back_inserter (p));
4536         }
4537
4538         p.sort ();
4539         p.unique ();
4540
4541         return p;
4542 }
4543
4544 void
4545 Session::update_latency (bool playback)
4546 {
4547         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4548
4549         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4550                 return;
4551         }
4552
4553         boost::shared_ptr<RouteList> r = routes.reader ();
4554         framecnt_t max_latency = 0;
4555
4556         if (playback) {
4557                 /* reverse the list so that we work backwards from the last route to run to the first */
4558                 RouteList* rl = routes.reader().get();
4559                 r.reset (new RouteList (*rl));
4560                 reverse (r->begin(), r->end());
4561         }
4562
4563         /* compute actual latency values for the given direction and store them all in per-port
4564            structures. this will also publish the same values (to JACK) so that computation of latency
4565            for routes can consistently use public latency values.
4566         */
4567
4568         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4569                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4570         }
4571
4572         /* because we latency compensate playback, our published playback latencies should
4573            be the same for all output ports - all material played back by ardour has
4574            the same latency, whether its caused by plugins or by latency compensation. since
4575            these may differ from the values computed above, reset all playback port latencies
4576            to the same value.
4577         */
4578
4579         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4580
4581         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4582                 (*i)->set_public_port_latencies (max_latency, playback);
4583         }
4584
4585         if (playback) {
4586
4587                 post_playback_latency ();
4588
4589         } else {
4590
4591                 post_capture_latency ();
4592         }
4593
4594         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4595 }
4596
4597 void
4598 Session::post_playback_latency ()
4599 {
4600         set_worst_playback_latency ();
4601
4602         boost::shared_ptr<RouteList> r = routes.reader ();
4603
4604         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4605                 if (!(*i)->is_hidden() && ((*i)->active())) {
4606                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4607                 }
4608         }
4609
4610         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4611                 (*i)->set_latency_compensation (_worst_track_latency);
4612         }
4613 }
4614
4615 void
4616 Session::post_capture_latency ()
4617 {
4618         set_worst_capture_latency ();
4619
4620         /* reflect any changes in capture latencies into capture offsets
4621          */
4622
4623         boost::shared_ptr<RouteList> rl = routes.reader();
4624         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4625                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4626                 if (tr) {
4627                         tr->set_capture_offset ();
4628                 }
4629         }
4630 }
4631
4632 void
4633 Session::initialize_latencies ()
4634 {
4635         {
4636                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4637                 update_latency (false);
4638                 update_latency (true);
4639         }
4640
4641         set_worst_io_latencies ();
4642 }
4643
4644 void
4645 Session::set_worst_io_latencies ()
4646 {
4647         set_worst_playback_latency ();
4648         set_worst_capture_latency ();
4649 }
4650
4651 void
4652 Session::set_worst_playback_latency ()
4653 {
4654         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4655                 return;
4656         }
4657
4658         _worst_output_latency = 0;
4659
4660         if (!_engine.connected()) {
4661                 return;
4662         }
4663
4664         boost::shared_ptr<RouteList> r = routes.reader ();
4665
4666         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4667                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4668         }
4669
4670         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4671 }
4672
4673 void
4674 Session::set_worst_capture_latency ()
4675 {
4676         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4677                 return;
4678         }
4679
4680         _worst_input_latency = 0;
4681
4682         if (!_engine.connected()) {
4683                 return;
4684         }
4685
4686         boost::shared_ptr<RouteList> r = routes.reader ();
4687
4688         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4689                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4690         }
4691
4692         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4693 }
4694
4695 void
4696 Session::update_latency_compensation (bool force_whole_graph)
4697 {
4698         bool some_track_latency_changed = false;
4699
4700         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4701                 return;
4702         }
4703
4704         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4705
4706         _worst_track_latency = 0;
4707
4708         boost::shared_ptr<RouteList> r = routes.reader ();
4709
4710         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4711                 if (!(*i)->is_hidden() && ((*i)->active())) {
4712                         framecnt_t tl;
4713                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4714                                 some_track_latency_changed = true;
4715                         }
4716                         _worst_track_latency = max (tl, _worst_track_latency);
4717                 }
4718         }
4719
4720         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4721                                                      (some_track_latency_changed ? "yes" : "no")));
4722
4723         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4724
4725         if (some_track_latency_changed || force_whole_graph)  {
4726                 _engine.update_latencies ();
4727         }
4728
4729
4730         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4731                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4732                 if (!tr) {
4733                         continue;
4734                 }
4735                 tr->set_capture_offset ();
4736         }
4737 }
4738
4739 char
4740 Session::session_name_is_legal (const string& path)
4741 {
4742         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4743
4744         for (int i = 0; illegal_chars[i]; ++i) {
4745                 if (path.find (illegal_chars[i]) != string::npos) {
4746                         return illegal_chars[i];
4747                 }
4748         }
4749
4750         return 0;
4751 }
4752
4753 uint32_t
4754 Session::next_control_id () const
4755 {
4756         int subtract = 0;
4757
4758         /* the monitor bus remote ID is in a different
4759          * "namespace" than regular routes. its existence doesn't
4760          * affect normal (low) numbered routes.
4761          */
4762
4763         if (_monitor_out) {
4764                 subtract++;
4765         }
4766
4767         return nroutes() - subtract;
4768 }
4769
4770 void
4771 Session::notify_remote_id_change ()
4772 {
4773         if (deletion_in_progress()) {
4774                 return;
4775         }
4776
4777         switch (Config->get_remote_model()) {
4778         case MixerSort:
4779         case EditorSort:
4780                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4781                 break;
4782         default:
4783                 break;
4784         }
4785 }
4786
4787 void
4788 Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
4789 {
4790         if (deletion_in_progress()) {
4791                 return;
4792         }
4793
4794         /* tell everyone that something has happened to the sort keys
4795            and let them sync up with the change(s)
4796            this will give objects that manage the sort order keys the
4797            opportunity to keep them in sync if they wish to.
4798         */
4799
4800         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
4801
4802         Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
4803
4804         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
4805 }
4806
4807 bool
4808 Session::operation_in_progress (GQuark op) const
4809 {
4810         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4811 }
4812
4813 boost::shared_ptr<Port>
4814 Session::ltc_input_port () const
4815 {
4816         return _ltc_input->nth (0);
4817 }
4818
4819 boost::shared_ptr<Port>
4820 Session::ltc_output_port () const
4821 {
4822         return _ltc_output->nth (0);
4823 }
4824
4825 void
4826 Session::reconnect_ltc_input ()
4827 {
4828         if (_ltc_input) {
4829
4830                 string src = Config->get_ltc_source_port();
4831
4832                 _ltc_input->disconnect (this);
4833
4834                 if (src != _("None") && !src.empty())  {
4835                         _ltc_input->nth (0)->connect (src);
4836                 }
4837         }
4838 }
4839
4840 void
4841 Session::reconnect_ltc_output ()
4842 {
4843         if (_ltc_output) {
4844
4845 #if 0
4846                 string src = Config->get_ltc_sink_port();
4847
4848                 _ltc_output->disconnect (this);
4849
4850                 if (src != _("None") && !src.empty())  {
4851                         _ltc_output->nth (0)->connect (src);
4852                 }
4853 #endif
4854         }
4855 }