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