libs/ardour/session.cc

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