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