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