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
1990                 /* if there is no control out and we're not in the middle of loading,
1991                    resort the graph here. if there is a control out, we will resort
1992                    toward the end of this method. if we are in the middle of loading,
1993                    we will resort when done.
1994                 */
1995
1996                 if (!_monitor_out && IO::connecting_legal) {
1997                         resort_routes_using (r);
1998                 }
1999         }
2000
2001         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2002
2003                 boost::weak_ptr<Route> wpr (*x);
2004                 boost::shared_ptr<Route> r (*x);
2005
2006                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2007                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2008                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2009                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2010                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2011                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2012                 r->order_key_changed.connect_same_thread (*this, boost::bind (&Session::route_order_key_changed, this));
2013
2014                 if (r->is_master()) {
2015                         _master_out = r;
2016                 }
2017
2018                 if (r->is_monitor()) {
2019                         _monitor_out = r;
2020                 }
2021
2022                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2023                 if (tr) {
2024                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2025                         track_playlist_changed (boost::weak_ptr<Track> (tr));
2026                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2027
2028                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2029                         if (mt) {
2030                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2031                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2032                         }
2033                 }
2034
2035                 if (auto_connect) {
2036                         auto_connect_route (r, existing_inputs, existing_outputs, true);
2037                 }
2038         }
2039
2040         if (_monitor_out && IO::connecting_legal) {
2041
2042                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2043                         if ((*x)->is_monitor()) {
2044                                 /* relax */
2045                         } else if ((*x)->is_master()) {
2046                                 /* relax */
2047                         } else {
2048                                 (*x)->listen_via_monitor ();
2049                         }
2050                 }
2051
2052                 resort_routes ();
2053         }
2054
2055         set_dirty();
2056
2057         if (save) {
2058                 save_state (_current_snapshot_name);
2059         }
2060
2061         RouteAdded (new_routes); /* EMIT SIGNAL */
2062         Route::RemoteControlIDChange (); /* EMIT SIGNAL */
2063 }
2064
2065 void
2066 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2067 {
2068         boost::shared_ptr<RouteList> r = routes.reader ();
2069         boost::shared_ptr<Send> s;
2070
2071         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2072                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2073                         s->amp()->gain_control()->set_value (0.0);
2074                 }
2075         }
2076 }
2077
2078 void
2079 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2080 {
2081         boost::shared_ptr<RouteList> r = routes.reader ();
2082         boost::shared_ptr<Send> s;
2083
2084         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2085                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2086                         s->amp()->gain_control()->set_value (1.0);
2087                 }
2088         }
2089 }
2090
2091 void
2092 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2093 {
2094         boost::shared_ptr<RouteList> r = routes.reader ();
2095         boost::shared_ptr<Send> s;
2096
2097         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2098                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2099                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2100                 }
2101         }
2102 }
2103
2104 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2105 void
2106 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2107 {
2108         boost::shared_ptr<RouteList> r = routes.reader ();
2109         boost::shared_ptr<RouteList> t (new RouteList);
2110
2111         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2112                 if (include_buses || boost::dynamic_pointer_cast<Track>(*i)) {
2113                         t->push_back (*i);
2114                 }
2115         }
2116
2117         add_internal_sends (dest, p, t);
2118 }
2119
2120 void
2121 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2122 {
2123         if (dest->is_monitor() || dest->is_master()) {
2124                 return;
2125         }
2126
2127         if (!dest->internal_return()) {
2128                 dest->add_internal_return();
2129         }
2130
2131         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2132
2133                 if ((*i)->is_monitor() || (*i)->is_master() || (*i) == dest) {
2134                         continue;
2135                 }
2136
2137                 (*i)->listen_via (dest, p);
2138         }
2139
2140         graph_reordered ();
2141 }
2142
2143 void
2144 Session::remove_route (boost::shared_ptr<Route> route)
2145 {
2146         if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
2147                 return;
2148         }
2149
2150         route->set_solo (false, this);
2151
2152         {
2153                 RCUWriter<RouteList> writer (routes);
2154                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2155
2156                 rs->remove (route);
2157
2158                 /* deleting the master out seems like a dumb
2159                    idea, but its more of a UI policy issue
2160                    than our concern.
2161                 */
2162
2163                 if (route == _master_out) {
2164                         _master_out = boost::shared_ptr<Route> ();
2165                 }
2166
2167                 if (route == _monitor_out) {
2168
2169                         /* cancel control outs for all routes */
2170
2171                         for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2172                                 (*r)->drop_listen (_monitor_out);
2173                         }
2174
2175                         _monitor_out.reset ();
2176                 }
2177
2178                 /* writer goes out of scope, forces route list update */
2179         }
2180
2181         update_route_solo_state ();
2182
2183         // We need to disconnect the route's inputs and outputs
2184
2185         route->input()->disconnect (0);
2186         route->output()->disconnect (0);
2187
2188         /* if the route had internal sends sending to it, remove them */
2189         if (route->internal_return()) {
2190
2191                 boost::shared_ptr<RouteList> r = routes.reader ();
2192                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2193                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2194                         if (s) {
2195                                 (*i)->remove_processor (s);
2196                         }
2197                 }
2198         }
2199
2200         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2201         if (mt && mt->step_editing()) {
2202                 if (_step_editors > 0) {
2203                         _step_editors--;
2204                 }
2205         }
2206
2207         update_latency_compensation ();
2208         set_dirty();
2209
2210         /* Re-sort routes to remove the graph's current references to the one that is
2211          * going away, then flush old references out of the graph.
2212          */
2213
2214         resort_routes ();
2215         route_graph->clear_other_chain ();
2216
2217         /* get rid of it from the dead wood collection in the route list manager */
2218
2219         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2220
2221         routes.flush ();
2222
2223         /* try to cause everyone to drop their references */
2224
2225         route->drop_references ();
2226
2227         sync_order_keys (N_("session"));
2228
2229         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2230
2231         /* save the new state of the world */
2232
2233         if (save_state (_current_snapshot_name)) {
2234                 save_history (_current_snapshot_name);
2235         }
2236 }
2237
2238 void
2239 Session::route_mute_changed (void* /*src*/)
2240 {
2241         set_dirty ();
2242 }
2243
2244 void
2245 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2246 {
2247         boost::shared_ptr<Route> route = wpr.lock();
2248         if (!route) {
2249                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2250                 return;
2251         }
2252
2253         if (route->listening_via_monitor ()) {
2254
2255                 if (Config->get_exclusive_solo()) {
2256                         /* new listen: disable all other listen */
2257                         boost::shared_ptr<RouteList> r = routes.reader ();
2258                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2259                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2260                                         continue;
2261                                 }
2262                                 (*i)->set_listen (false, this);
2263                         }
2264                 }
2265
2266                 _listen_cnt++;
2267
2268         } else if (_listen_cnt > 0) {
2269
2270                 _listen_cnt--;
2271         }
2272
2273         update_route_solo_state ();
2274 }
2275 void
2276 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2277 {
2278         boost::shared_ptr<Route> route = wpr.lock ();
2279
2280         if (!route) {
2281                 /* should not happen */
2282                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2283                 return;
2284         }
2285
2286         bool send_changed = false;
2287
2288         if (route->solo_isolated()) {
2289                 if (_solo_isolated_cnt == 0) {
2290                         send_changed = true;
2291                 }
2292                 _solo_isolated_cnt++;
2293         } else if (_solo_isolated_cnt > 0) {
2294                 _solo_isolated_cnt--;
2295                 if (_solo_isolated_cnt == 0) {
2296                         send_changed = true;
2297                 }
2298         }
2299
2300         if (send_changed) {
2301                 IsolatedChanged (); /* EMIT SIGNAL */
2302         }
2303 }
2304
2305 void
2306 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2307 {
2308         if (!self_solo_change) {
2309                 // session doesn't care about changes to soloed-by-others
2310                 return;
2311         }
2312
2313         if (solo_update_disabled) {
2314                 // We know already
2315                 return;
2316         }
2317
2318         boost::shared_ptr<Route> route = wpr.lock ();
2319
2320         if (!route) {
2321                 /* should not happen */
2322                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2323                 return;
2324         }
2325
2326         boost::shared_ptr<RouteList> r = routes.reader ();
2327         int32_t delta;
2328
2329         if (route->self_soloed()) {
2330                 delta = 1;
2331         } else {
2332                 delta = -1;
2333         }
2334
2335         if (delta == 1 && Config->get_exclusive_solo()) {
2336                 /* new solo: disable all other solos */
2337                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2338                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2339                                 continue;
2340                         }
2341                         (*i)->set_solo (false, this);
2342                 }
2343         }
2344
2345         solo_update_disabled = true;
2346
2347         RouteList uninvolved;
2348
2349         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2350                 bool via_sends_only;
2351                 bool in_signal_flow;
2352
2353                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2354                         continue;
2355                 }
2356
2357                 in_signal_flow = false;
2358
2359                 if ((*i)->feeds (route, &via_sends_only)) {
2360                         if (!via_sends_only) {
2361                                 if (!route->soloed_by_others_upstream()) {
2362                                         (*i)->mod_solo_by_others_downstream (delta);
2363                                 }
2364                                 in_signal_flow = true;
2365                         }
2366                 }
2367
2368                 if (route->feeds (*i, &via_sends_only)) {
2369                         (*i)->mod_solo_by_others_upstream (delta);
2370                         in_signal_flow = true;
2371                 }
2372
2373                 if (!in_signal_flow) {
2374                         uninvolved.push_back (*i);
2375                 }
2376         }
2377
2378         solo_update_disabled = false;
2379         update_route_solo_state (r);
2380
2381         /* now notify that the mute state of the routes not involved in the signal
2382            pathway of the just-solo-changed route may have altered.
2383         */
2384
2385         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2386                 (*i)->mute_changed (this);
2387         }
2388
2389         SoloChanged (); /* EMIT SIGNAL */
2390         set_dirty();
2391 }
2392
2393 void
2394 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2395 {
2396         /* now figure out if anything that matters is soloed (or is "listening")*/
2397
2398         bool something_soloed = false;
2399         uint32_t listeners = 0;
2400         uint32_t isolated = 0;
2401
2402         if (!r) {
2403                 r = routes.reader();
2404         }
2405
2406         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2407                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2408                         something_soloed = true;
2409                 }
2410
2411                 if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
2412                         if (Config->get_solo_control_is_listen_control()) {
2413                                 listeners++;
2414                         } else {
2415                                 (*i)->set_listen (false, this);
2416                         }
2417                 }
2418
2419                 if ((*i)->solo_isolated()) {
2420                         isolated++;
2421                 }
2422         }
2423
2424         if (something_soloed != _non_soloed_outs_muted) {
2425                 _non_soloed_outs_muted = something_soloed;
2426                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2427         }
2428
2429         _listen_cnt = listeners;
2430
2431         if (isolated != _solo_isolated_cnt) {
2432                 _solo_isolated_cnt = isolated;
2433                 IsolatedChanged (); /* EMIT SIGNAL */
2434         }
2435 }
2436
2437 boost::shared_ptr<RouteList>
2438 Session::get_routes_with_internal_returns() const
2439 {
2440         boost::shared_ptr<RouteList> r = routes.reader ();
2441         boost::shared_ptr<RouteList> rl (new RouteList);
2442
2443         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2444                 if ((*i)->internal_return ()) {
2445                         rl->push_back (*i);
2446                 }
2447         }
2448         return rl;
2449 }
2450
2451 bool
2452 Session::io_name_is_legal (const std::string& name)
2453 {
2454         boost::shared_ptr<RouteList> r = routes.reader ();
2455
2456         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2457                 if ((*i)->name() == name) {
2458                         return false;
2459                 }
2460
2461                 if ((*i)->has_io_processor_named (name)) {
2462                         return false;
2463                 }
2464         }
2465
2466         return true;
2467 }
2468
2469 void
2470 Session::set_exclusive_input_active (boost::shared_ptr<Route> rt, bool others_on)
2471 {
2472         RouteList rl;
2473         vector<string> connections;
2474
2475         PortSet& ps (rt->input()->ports());
2476
2477         for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2478                 p->get_connections (connections);
2479         }
2480
2481         for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2482                 routes_using_input_from (*s, rl);
2483         }
2484
2485         /* scan all relevant routes to see if others are on or off */
2486
2487         bool others_are_already_on = false;
2488
2489         for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2490                 if ((*r) != rt) {
2491                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2492                         if (mt) {
2493                                 if (mt->input_active()) {
2494                                         others_are_already_on = true;
2495                                         break;
2496                                 }
2497                         }
2498                 }
2499         }
2500
2501         /* globally reverse other routes */
2502
2503         for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2504                 if ((*r) != rt) {
2505                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2506                         if (mt) {
2507                                 mt->set_input_active (!others_are_already_on);
2508                         }
2509                 }
2510         }
2511 }
2512
2513 void
2514 Session::routes_using_input_from (const string& str, RouteList& rl)
2515 {
2516         boost::shared_ptr<RouteList> r = routes.reader ();
2517
2518         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2519                 if ((*i)->input()->connected_to (str)) {
2520                         rl.push_back (*i);
2521                 }
2522         }
2523 }
2524
2525 boost::shared_ptr<Route>
2526 Session::route_by_name (string name)
2527 {
2528         boost::shared_ptr<RouteList> r = routes.reader ();
2529
2530         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2531                 if ((*i)->name() == name) {
2532                         return *i;
2533                 }
2534         }
2535
2536         return boost::shared_ptr<Route> ((Route*) 0);
2537 }
2538
2539 boost::shared_ptr<Route>
2540 Session::route_by_id (PBD::ID id)
2541 {
2542         boost::shared_ptr<RouteList> r = routes.reader ();
2543
2544         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2545                 if ((*i)->id() == id) {
2546                         return *i;
2547                 }
2548         }
2549
2550         return boost::shared_ptr<Route> ((Route*) 0);
2551 }
2552
2553 boost::shared_ptr<Route>
2554 Session::route_by_remote_id (uint32_t id)
2555 {
2556         boost::shared_ptr<RouteList> r = routes.reader ();
2557
2558         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2559                 if ((*i)->remote_control_id() == id) {
2560                         return *i;
2561                 }
2562         }
2563
2564         return boost::shared_ptr<Route> ((Route*) 0);
2565 }
2566
2567 void
2568 Session::playlist_region_added (boost::weak_ptr<Region> w)
2569 {
2570         boost::shared_ptr<Region> r = w.lock ();
2571         if (!r) {
2572                 return;
2573         }
2574
2575         /* These are the operations that are currently in progress... */
2576         list<GQuark> curr = _current_trans_quarks;
2577         curr.sort ();
2578
2579         /* ...and these are the operations during which we want to update
2580            the session range location markers.
2581         */
2582         list<GQuark> ops;
2583         ops.push_back (Operations::capture);
2584         ops.push_back (Operations::paste);
2585         ops.push_back (Operations::duplicate_region);
2586         ops.push_back (Operations::insert_file);
2587         ops.push_back (Operations::insert_region);
2588         ops.push_back (Operations::drag_region_brush);
2589         ops.push_back (Operations::region_drag);
2590         ops.push_back (Operations::selection_grab);
2591         ops.push_back (Operations::region_fill);
2592         ops.push_back (Operations::fill_selection);
2593         ops.push_back (Operations::create_region);
2594         ops.push_back (Operations::region_copy);
2595         ops.push_back (Operations::fixed_time_region_copy);
2596         ops.sort ();
2597
2598         /* See if any of the current operations match the ones that we want */
2599         list<GQuark> in;
2600         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2601
2602         /* If so, update the session range markers */
2603         if (!in.empty ()) {
2604                 maybe_update_session_range (r->position (), r->last_frame ());
2605         }
2606 }
2607
2608 /** Update the session range markers if a is before the current start or
2609  *  b is after the current end.
2610  */
2611 void
2612 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2613 {
2614         if (_state_of_the_state & Loading) {
2615                 return;
2616         }
2617
2618         if (_session_range_location == 0) {
2619
2620                 add_session_range_location (a, b);
2621
2622         } else {
2623
2624                 if (a < _session_range_location->start()) {
2625                         _session_range_location->set_start (a);
2626                 }
2627
2628                 if (b > _session_range_location->end()) {
2629                         _session_range_location->set_end (b);
2630                 }
2631         }
2632 }
2633
2634 void
2635 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2636 {
2637         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2638                 maybe_update_session_range (i->to, i->to + i->length);
2639         }
2640 }
2641
2642 void
2643 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2644 {
2645         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2646                 maybe_update_session_range (i->from, i->to);
2647         }
2648 }
2649
2650 /* Region management */
2651
2652 boost::shared_ptr<Region>
2653 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2654 {
2655         const RegionFactory::RegionMap& regions (RegionFactory::regions());
2656         RegionFactory::RegionMap::const_iterator i;
2657         boost::shared_ptr<Region> region;
2658
2659         Glib::Mutex::Lock lm (region_lock);
2660
2661         for (i = regions.begin(); i != regions.end(); ++i) {
2662
2663                 region = i->second;
2664
2665                 if (region->whole_file()) {
2666
2667                         if (child->source_equivalent (region)) {
2668                                 return region;
2669                         }
2670                 }
2671         }
2672
2673         return boost::shared_ptr<Region> ();
2674 }
2675
2676 int
2677 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2678 {
2679         set<boost::shared_ptr<Region> > relevant_regions;
2680
2681         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2682                 RegionFactory::get_regions_using_source (*s, relevant_regions);
2683         }
2684
2685         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2686                 set<boost::shared_ptr<Region> >::iterator tmp;
2687
2688                 tmp = r;
2689                 ++tmp;
2690
2691                 playlists->destroy_region (*r);
2692                 RegionFactory::map_remove (*r);
2693
2694                 (*r)->drop_sources ();
2695                 (*r)->drop_references ();
2696
2697                 relevant_regions.erase (r);
2698
2699                 r = tmp;
2700         }
2701
2702         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2703
2704                 {
2705                         Glib::Mutex::Lock ls (source_lock);
2706                         /* remove from the main source list */
2707                         sources.erase ((*s)->id());
2708                 }
2709
2710                 (*s)->mark_for_remove ();
2711                 (*s)->drop_references ();
2712
2713                 s = srcs.erase (s);
2714         }
2715
2716         return 0;
2717 }
2718
2719 int
2720 Session::remove_last_capture ()
2721 {
2722         list<boost::shared_ptr<Source> > srcs;
2723
2724         boost::shared_ptr<RouteList> rl = routes.reader ();
2725         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2726                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2727                 if (!tr) {
2728                         continue;
2729                 }
2730
2731                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
2732
2733                 if (!l.empty()) {
2734                         srcs.insert (srcs.end(), l.begin(), l.end());
2735                         l.clear ();
2736                 }
2737         }
2738
2739         destroy_sources (srcs);
2740
2741         save_state (_current_snapshot_name);
2742
2743         return 0;
2744 }
2745
2746 /* Source Management */
2747
2748 void
2749 Session::add_source (boost::shared_ptr<Source> source)
2750 {
2751         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
2752         pair<SourceMap::iterator,bool> result;
2753
2754         entry.first = source->id();
2755         entry.second = source;
2756
2757         {
2758                 Glib::Mutex::Lock lm (source_lock);
2759                 result = sources.insert (entry);
2760         }
2761
2762         if (result.second) {
2763
2764                 /* yay, new source */
2765
2766                 set_dirty();
2767
2768                 boost::shared_ptr<AudioFileSource> afs;
2769
2770                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2771                         if (Config->get_auto_analyse_audio()) {
2772                                 Analyser::queue_source_for_analysis (source, false);
2773                         }
2774                 }
2775
2776                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
2777         }
2778 }
2779
2780 void
2781 Session::remove_source (boost::weak_ptr<Source> src)
2782 {
2783         if (_state_of_the_state & Deletion) {
2784                 return;
2785         }
2786
2787         SourceMap::iterator i;
2788         boost::shared_ptr<Source> source = src.lock();
2789
2790         if (!source) {
2791                 return;
2792         }
2793
2794         {
2795                 Glib::Mutex::Lock lm (source_lock);
2796
2797                 if ((i = sources.find (source->id())) != sources.end()) {
2798                         sources.erase (i);
2799                 }
2800         }
2801
2802         if (!_state_of_the_state & InCleanup) {
2803
2804                 /* save state so we don't end up with a session file
2805                    referring to non-existent sources.
2806                 */
2807
2808                 save_state (_current_snapshot_name);
2809         }
2810 }
2811
2812 boost::shared_ptr<Source>
2813 Session::source_by_id (const PBD::ID& id)
2814 {
2815         Glib::Mutex::Lock lm (source_lock);
2816         SourceMap::iterator i;
2817         boost::shared_ptr<Source> source;
2818
2819         if ((i = sources.find (id)) != sources.end()) {
2820                 source = i->second;
2821         }
2822
2823         return source;
2824 }
2825
2826 boost::shared_ptr<Source>
2827 Session::source_by_path_and_channel (const string& path, uint16_t chn)
2828 {
2829         Glib::Mutex::Lock lm (source_lock);
2830
2831         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2832                 boost::shared_ptr<AudioFileSource> afs
2833                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2834
2835                 if (afs && afs->path() == path && chn == afs->channel()) {
2836                         return afs;
2837                 }
2838         }
2839         return boost::shared_ptr<Source>();
2840 }
2841
2842 uint32_t
2843 Session::count_sources_by_origin (const string& path)
2844 {
2845         uint32_t cnt = 0;
2846         Glib::Mutex::Lock lm (source_lock);
2847
2848         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2849                 boost::shared_ptr<FileSource> fs
2850                         = boost::dynamic_pointer_cast<FileSource>(i->second);
2851
2852                 if (fs && fs->origin() == path) {
2853                         ++cnt;
2854                 }
2855         }
2856
2857         return cnt;
2858 }
2859
2860
2861 string
2862 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
2863 {
2864         string look_for;
2865         string old_basename = PBD::basename_nosuffix (oldname);
2866         string new_legalized = legalize_for_path (newname);
2867
2868         /* note: we know (or assume) the old path is already valid */
2869
2870         if (destructive) {
2871
2872                 /* destructive file sources have a name of the form:
2873
2874                     /path/to/Tnnnn-NAME(%[LR])?.wav
2875
2876                     the task here is to replace NAME with the new name.
2877                 */
2878
2879                 string dir;
2880                 string prefix;
2881                 string::size_type dash;
2882
2883                 dir = Glib::path_get_dirname (path);
2884                 path = Glib::path_get_basename (path);
2885
2886                 /* '-' is not a legal character for the NAME part of the path */
2887
2888                 if ((dash = path.find_last_of ('-')) == string::npos) {
2889                         return "";
2890                 }
2891
2892                 prefix = path.substr (0, dash);
2893
2894                 path += prefix;
2895                 path += '-';
2896                 path += new_legalized;
2897                 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
2898                 path = Glib::build_filename (dir, path);
2899
2900         } else {
2901
2902                 /* non-destructive file sources have a name of the form:
2903
2904                     /path/to/NAME-nnnnn(%[LR])?.ext
2905
2906                     the task here is to replace NAME with the new name.
2907                 */
2908
2909                 string dir;
2910                 string suffix;
2911                 string::size_type dash;
2912                 string::size_type postfix;
2913
2914                 dir = Glib::path_get_dirname (path);
2915                 path = Glib::path_get_basename (path);
2916
2917                 /* '-' is not a legal character for the NAME part of the path */
2918
2919                 if ((dash = path.find_last_of ('-')) == string::npos) {
2920                         return "";
2921                 }
2922
2923                 suffix = path.substr (dash+1);
2924
2925                 // Suffix is now everything after the dash. Now we need to eliminate
2926                 // the nnnnn part, which is done by either finding a '%' or a '.'
2927
2928                 postfix = suffix.find_last_of ("%");
2929                 if (postfix == string::npos) {
2930                         postfix = suffix.find_last_of ('.');
2931                 }
2932
2933                 if (postfix != string::npos) {
2934                         suffix = suffix.substr (postfix);
2935                 } else {
2936                         error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
2937                         return "";
2938                 }
2939
2940                 const uint32_t limit = 10000;
2941                 char buf[PATH_MAX+1];
2942
2943                 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
2944
2945                         snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
2946
2947                         if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
2948                                 path = Glib::build_filename (dir, buf);
2949                                 break;
2950                         }
2951
2952                         path = "";
2953                 }
2954
2955                 if (path.empty()) {
2956                         fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
2957                                                  newname) << endl;
2958                         /*NOTREACHED*/
2959                 }
2960         }
2961
2962         return path;
2963 }
2964
2965 /** Return the full path (in some session directory) for a new within-session source.
2966  * \a name must be a session-unique name that does not contain slashes
2967  *         (e.g. as returned by new_*_source_name)
2968  */
2969 string
2970 Session::new_source_path_from_name (DataType type, const string& name)
2971 {
2972         assert(name.find("/") == string::npos);
2973
2974         SessionDirectory sdir(get_best_session_directory_for_new_source());
2975
2976         sys::path p;
2977         if (type == DataType::AUDIO) {
2978                 p = sdir.sound_path();
2979         } else if (type == DataType::MIDI) {
2980                 p = sdir.midi_path();
2981         } else {
2982                 error << "Unknown source type, unable to create file path" << endmsg;
2983                 return "";
2984         }
2985
2986         p /= name;
2987         return p.to_string();
2988 }
2989
2990 string
2991 Session::peak_path (string base) const
2992 {
2993         sys::path peakfile_path(_session_dir->peak_path());
2994         peakfile_path /= base + peakfile_suffix;
2995         return peakfile_path.to_string();
2996 }
2997
2998 /** Return a unique name based on \a base for a new internal audio source */
2999 string
3000 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3001 {
3002         uint32_t cnt;
3003         char buf[PATH_MAX+1];
3004         const uint32_t limit = 10000;
3005         string legalized;
3006         string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3007
3008         buf[0] = '\0';
3009         legalized = legalize_for_path (base);
3010
3011         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3012         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3013
3014                 vector<space_and_path>::iterator i;
3015                 uint32_t existing = 0;
3016
3017                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3018
3019                         if (destructive) {
3020
3021                                 if (nchan < 2) {
3022                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3023                                                   cnt, legalized.c_str(), ext.c_str());
3024                                 } else if (nchan == 2) {
3025                                         if (chan == 0) {
3026                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3027                                                           cnt, legalized.c_str(), ext.c_str());
3028                                         } else {
3029                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3030                                                           cnt, legalized.c_str(), ext.c_str());
3031                                         }
3032                                 } else if (nchan < 26) {
3033                                         snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3034                                                   cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3035                                 } else {
3036                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3037                                                   cnt, legalized.c_str(), ext.c_str());
3038                                 }
3039
3040                         } else {
3041
3042                                 if (nchan < 2) {
3043                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3044                                 } else if (nchan == 2) {
3045                                         if (chan == 0) {
3046                                                 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3047                                         } else {
3048                                                 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3049                                         }
3050                                 } else if (nchan < 26) {
3051                                         snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3052                                 } else {
3053                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3054                                 }
3055                         }
3056
3057                         SessionDirectory sdir((*i).path);
3058
3059                         string spath = sdir.sound_path().to_string();
3060
3061                         /* note that we search *without* the extension so that
3062                            we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3063                            in the event that this new name is required for
3064                            a file format change.
3065                         */
3066
3067                         if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3068                                 existing++;
3069                                 break;
3070                         }
3071                 }
3072
3073                 if (existing == 0) {
3074                         break;
3075                 }
3076
3077                 if (cnt > limit) {
3078                         error << string_compose(
3079                                         _("There are already %1 recordings for %2, which I consider too many."),
3080                                         limit, base) << endmsg;
3081                         destroy ();
3082                         throw failed_constructor();
3083                 }
3084         }
3085
3086         return Glib::path_get_basename (buf);
3087 }
3088
3089 /** Create a new within-session audio source */
3090 boost::shared_ptr<AudioFileSource>
3091 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3092 {
3093         const string name    = new_audio_source_name (n, n_chans, chan, destructive);
3094         const string path    = new_source_path_from_name(DataType::AUDIO, name);
3095
3096         return boost::dynamic_pointer_cast<AudioFileSource> (
3097                 SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
3098 }
3099
3100 /** Return a unique name based on \a base for a new internal MIDI source */
3101 string
3102 Session::new_midi_source_name (const string& base)
3103 {
3104         uint32_t cnt;
3105         char buf[PATH_MAX+1];
3106         const uint32_t limit = 10000;
3107         string legalized;
3108
3109         buf[0] = '\0';
3110         legalized = legalize_for_path (base);
3111
3112         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3113         for (cnt = 1; cnt <= limit; ++cnt) {
3114
3115                 vector<space_and_path>::iterator i;
3116                 uint32_t existing = 0;
3117
3118                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3119
3120                         SessionDirectory sdir((*i).path);
3121
3122                         sys::path p = sdir.midi_path();
3123                         p /= legalized;
3124
3125                         snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
3126
3127                         if (sys::exists (buf)) {
3128                                 existing++;
3129                         }
3130                 }
3131
3132                 if (existing == 0) {
3133                         break;
3134                 }
3135
3136                 if (cnt > limit) {
3137                         error << string_compose(
3138                                         _("There are already %1 recordings for %2, which I consider too many."),
3139                                         limit, base) << endmsg;
3140                         destroy ();
3141                         throw failed_constructor();
3142                 }
3143         }
3144
3145         return Glib::path_get_basename(buf);
3146 }
3147
3148
3149 /** Create a new within-session MIDI source */
3150 boost::shared_ptr<MidiSource>
3151 Session::create_midi_source_for_session (Track* track, string const & n)
3152 {
3153         /* try to use the existing write source for the track, to keep numbering sane
3154          */
3155
3156         if (track) {
3157                 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3158                   assert (mt);
3159                 */
3160
3161                 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3162
3163                 if (!l.empty()) {
3164                         assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3165                         return boost::dynamic_pointer_cast<MidiSource> (l.front());
3166                 }
3167         }
3168
3169         const string name = new_midi_source_name (n);
3170         const string path = new_source_path_from_name (DataType::MIDI, name);
3171
3172         return boost::dynamic_pointer_cast<SMFSource> (
3173                 SourceFactory::createWritable (
3174                         DataType::MIDI, *this, path, string(), false, frame_rate()));
3175 }
3176
3177
3178 void
3179 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3180 {
3181         if (playlist->hidden()) {
3182                 return;
3183         }
3184
3185         playlists->add (playlist);
3186
3187         if (unused) {
3188                 playlist->release();
3189         }
3190
3191         set_dirty();
3192 }
3193
3194 void
3195 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3196 {
3197         if (_state_of_the_state & Deletion) {
3198                 return;
3199         }
3200
3201         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3202
3203         if (!playlist) {
3204                 return;
3205         }
3206
3207         playlists->remove (playlist);
3208
3209         set_dirty();
3210 }
3211
3212 void
3213 Session::set_audition (boost::shared_ptr<Region> r)
3214 {
3215         pending_audition_region = r;
3216         add_post_transport_work (PostTransportAudition);
3217         _butler->schedule_transport_work ();
3218 }
3219
3220 void
3221 Session::audition_playlist ()
3222 {
3223         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3224         ev->region.reset ();
3225         queue_event (ev);
3226 }
3227
3228 void
3229 Session::non_realtime_set_audition ()
3230 {
3231         if (!pending_audition_region) {
3232                 auditioner->audition_current_playlist ();
3233         } else {
3234                 auditioner->audition_region (pending_audition_region);
3235                 pending_audition_region.reset ();
3236         }
3237         AuditionActive (true); /* EMIT SIGNAL */
3238 }
3239
3240 void
3241 Session::audition_region (boost::shared_ptr<Region> r)
3242 {
3243         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3244         ev->region = r;
3245         queue_event (ev);
3246 }
3247
3248 void
3249 Session::cancel_audition ()
3250 {
3251         if (auditioner->auditioning()) {
3252                 auditioner->cancel_audition ();
3253                 AuditionActive (false); /* EMIT SIGNAL */
3254         }
3255 }
3256
3257 bool
3258 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3259 {
3260         if (a->is_monitor()) {
3261                 return true;
3262         }
3263         if (b->is_monitor()) {
3264                 return false;
3265         }
3266         return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3267 }
3268
3269 bool
3270 Session::is_auditioning () const
3271 {
3272         /* can be called before we have an auditioner object */
3273         if (auditioner) {
3274                 return auditioner->auditioning();
3275         } else {
3276                 return false;
3277         }
3278 }
3279
3280 void
3281 Session::graph_reordered ()
3282 {
3283         /* don't do this stuff if we are setting up connections
3284            from a set_state() call or creating new tracks. Ditto for deletion.
3285         */
3286
3287         if (_state_of_the_state & (InitialConnecting|Deletion)) {
3288                 return;
3289         }
3290
3291         /* every track/bus asked for this to be handled but it was deferred because
3292            we were connecting. do it now.
3293         */
3294
3295         request_input_change_handling ();
3296
3297         resort_routes ();
3298
3299         /* force all diskstreams to update their capture offset values to
3300            reflect any changes in latencies within the graph.
3301         */
3302
3303         boost::shared_ptr<RouteList> rl = routes.reader ();
3304         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3305                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3306                 if (tr) {
3307                         tr->set_capture_offset ();
3308                 }
3309         }
3310 }
3311
3312 framecnt_t
3313 Session::available_capture_duration ()
3314 {
3315         float sample_bytes_on_disk = 4.0; // keep gcc happy
3316
3317         switch (config.get_native_file_data_format()) {
3318         case FormatFloat:
3319                 sample_bytes_on_disk = 4.0;
3320                 break;
3321
3322         case FormatInt24:
3323                 sample_bytes_on_disk = 3.0;
3324                 break;
3325
3326         case FormatInt16:
3327                 sample_bytes_on_disk = 2.0;
3328                 break;
3329
3330         default:
3331                 /* impossible, but keep some gcc versions happy */
3332                 fatal << string_compose (_("programming error: %1"),
3333                                          X_("illegal native file data format"))
3334                       << endmsg;
3335                 /*NOTREACHED*/
3336         }
3337
3338         double scale = 4096.0 / sample_bytes_on_disk;
3339
3340         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3341                 return max_framecnt;
3342         }
3343
3344         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3345 }
3346
3347 void
3348 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3349 {
3350         {
3351                 RCUWriter<BundleList> writer (_bundles);
3352                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3353                 b->push_back (bundle);
3354         }
3355
3356         BundleAdded (bundle); /* EMIT SIGNAL */
3357
3358         set_dirty();
3359 }
3360
3361 void
3362 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3363 {
3364         bool removed = false;
3365
3366         {
3367                 RCUWriter<BundleList> writer (_bundles);
3368                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3369                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3370
3371                 if (i != b->end()) {
3372                         b->erase (i);
3373                         removed = true;
3374                 }
3375         }
3376
3377         if (removed) {
3378                  BundleRemoved (bundle); /* EMIT SIGNAL */
3379         }
3380
3381         set_dirty();
3382 }
3383
3384 boost::shared_ptr<Bundle>
3385 Session::bundle_by_name (string name) const
3386 {
3387         boost::shared_ptr<BundleList> b = _bundles.reader ();
3388
3389         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3390                 if ((*i)->name() == name) {
3391                         return* i;
3392                 }
3393         }
3394
3395         return boost::shared_ptr<Bundle> ();
3396 }
3397
3398 void
3399 Session::tempo_map_changed (const PropertyChange&)
3400 {
3401         clear_clicks ();
3402
3403         playlists->update_after_tempo_map_change ();
3404
3405         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3406
3407         set_dirty ();
3408 }
3409
3410 void
3411 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3412 {
3413         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3414                 (*i)->recompute_frames_from_bbt ();
3415         }
3416 }
3417
3418 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3419  * the given count with the current block size.
3420  */
3421 void
3422 Session::ensure_buffers (ChanCount howmany)
3423 {
3424         BufferManager::ensure_buffers (howmany);
3425 }
3426
3427 void
3428 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3429 {
3430         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3431                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3432         }
3433 }
3434
3435 uint32_t
3436 Session::next_insert_id ()
3437 {
3438         /* this doesn't really loop forever. just think about it */
3439
3440         while (true) {
3441                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3442                         if (!insert_bitset[n]) {
3443                                 insert_bitset[n] = true;
3444                                 return n;
3445
3446                         }
3447                 }
3448
3449                 /* none available, so resize and try again */
3450
3451                 insert_bitset.resize (insert_bitset.size() + 16, false);
3452         }
3453 }
3454
3455 uint32_t
3456 Session::next_send_id ()
3457 {
3458         /* this doesn't really loop forever. just think about it */
3459
3460         while (true) {
3461                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3462                         if (!send_bitset[n]) {
3463                                 send_bitset[n] = true;
3464                                 return n;
3465
3466                         }
3467                 }
3468
3469                 /* none available, so resize and try again */
3470
3471                 send_bitset.resize (send_bitset.size() + 16, false);
3472         }
3473 }
3474
3475 uint32_t
3476 Session::next_return_id ()
3477 {
3478         /* this doesn't really loop forever. just think about it */
3479
3480         while (true) {
3481                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3482                         if (!return_bitset[n]) {
3483                                 return_bitset[n] = true;
3484                                 return n;
3485
3486                         }
3487                 }
3488
3489                 /* none available, so resize and try again */
3490
3491                 return_bitset.resize (return_bitset.size() + 16, false);
3492         }
3493 }
3494
3495 void
3496 Session::mark_send_id (uint32_t id)
3497 {
3498         if (id >= send_bitset.size()) {
3499                 send_bitset.resize (id+16, false);
3500         }
3501         if (send_bitset[id]) {
3502                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3503         }
3504         send_bitset[id] = true;
3505 }
3506
3507 void
3508 Session::mark_return_id (uint32_t id)
3509 {
3510         if (id >= return_bitset.size()) {
3511                 return_bitset.resize (id+16, false);
3512         }
3513         if (return_bitset[id]) {
3514                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3515         }
3516         return_bitset[id] = true;
3517 }
3518
3519 void
3520 Session::mark_insert_id (uint32_t id)
3521 {
3522         if (id >= insert_bitset.size()) {
3523                 insert_bitset.resize (id+16, false);
3524         }
3525         if (insert_bitset[id]) {
3526                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3527         }
3528         insert_bitset[id] = true;
3529 }
3530
3531 void
3532 Session::unmark_send_id (uint32_t id)
3533 {
3534         if (id < send_bitset.size()) {
3535                 send_bitset[id] = false;
3536         }
3537 }
3538
3539 void
3540 Session::unmark_return_id (uint32_t id)
3541 {
3542         if (id < return_bitset.size()) {
3543                 return_bitset[id] = false;
3544         }
3545 }
3546
3547 void
3548 Session::unmark_insert_id (uint32_t id)
3549 {
3550         if (id < insert_bitset.size()) {
3551                 insert_bitset[id] = false;
3552         }
3553 }
3554
3555
3556 /* Named Selection management */
3557
3558 boost::shared_ptr<NamedSelection>
3559 Session::named_selection_by_name (string name)
3560 {
3561         Glib::Mutex::Lock lm (named_selection_lock);
3562         for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3563                 if ((*i)->name == name) {
3564                         return *i;
3565                 }
3566         }
3567         return boost::shared_ptr<NamedSelection>();
3568 }
3569
3570 void
3571 Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3572 {
3573         {
3574                 Glib::Mutex::Lock lm (named_selection_lock);
3575                 named_selections.insert (named_selections.begin(), named_selection);
3576         }
3577
3578         set_dirty();
3579
3580         NamedSelectionAdded (); /* EMIT SIGNAL */
3581 }
3582
3583 void
3584 Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3585 {
3586         bool removed = false;
3587
3588         {
3589                 Glib::Mutex::Lock lm (named_selection_lock);
3590
3591                 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3592
3593                 if (i != named_selections.end()) {
3594                         named_selections.erase (i);
3595                         set_dirty();
3596                         removed = true;
3597                 }
3598         }
3599
3600         if (removed) {
3601                  NamedSelectionRemoved (); /* EMIT SIGNAL */
3602         }
3603 }
3604
3605 void
3606 Session::reset_native_file_format ()
3607 {
3608         boost::shared_ptr<RouteList> rl = routes.reader ();
3609         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3610                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3611                 if (tr) {
3612                         /* don't save state as we do this, there's no point
3613                          */
3614
3615                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3616                         tr->reset_write_sources (false);
3617                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3618                 }
3619         }
3620 }
3621
3622 bool
3623 Session::route_name_unique (string n) const
3624 {
3625         boost::shared_ptr<RouteList> r = routes.reader ();
3626
3627         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3628                 if ((*i)->name() == n) {
3629                         return false;
3630                 }
3631         }
3632
3633         return true;
3634 }
3635
3636 bool
3637 Session::route_name_internal (string n) const
3638 {
3639         if (auditioner && auditioner->name() == n) {
3640                 return true;
3641         }
3642
3643         if (_click_io && _click_io->name() == n) {
3644                 return true;
3645         }
3646
3647         return false;
3648 }
3649
3650 int
3651 Session::freeze_all (InterThreadInfo& itt)
3652 {
3653         boost::shared_ptr<RouteList> r = routes.reader ();
3654
3655         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3656
3657                 boost::shared_ptr<Track> t;
3658
3659                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3660                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3661                            of every track.
3662                         */
3663                         t->freeze_me (itt);
3664                 }
3665         }
3666
3667         return 0;
3668 }
3669
3670 boost::shared_ptr<Region>
3671 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3672                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3673                           InterThreadInfo& itt, bool enable_processing)
3674 {
3675         boost::shared_ptr<Region> result;
3676         boost::shared_ptr<Playlist> playlist;
3677         boost::shared_ptr<AudioFileSource> fsource;
3678         uint32_t x;
3679         char buf[PATH_MAX+1];
3680         ChanCount diskstream_channels (track.n_channels());
3681         framepos_t position;
3682         framecnt_t this_chunk;
3683         framepos_t to_do;
3684         BufferSet buffers;
3685         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3686         const string sound_dir = sdir.sound_path().to_string();
3687         framepos_t len = end - start;
3688         bool need_block_size_reset = false;
3689         string ext;
3690         ChanCount const max_proc = track.max_processor_streams ();
3691
3692         if (end <= start) {
3693                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3694                                          end, start) << endmsg;
3695                 return result;
3696         }
3697
3698         const framecnt_t chunk_size = (256 * 1024)/4;
3699
3700         // block all process callback handling
3701
3702         block_processing ();
3703
3704         /* call tree *MUST* hold route_lock */
3705
3706         if ((playlist = track.playlist()) == 0) {
3707                 goto out;
3708         }
3709
3710         /* external redirects will be a problem */
3711
3712         if (track.has_external_redirects()) {
3713                 goto out;
3714         }
3715
3716         ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3717
3718         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3719
3720                 for (x = 0; x < 99999; ++x) {
3721                         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());
3722                         if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3723                                 break;
3724                         }
3725                 }
3726
3727                 if (x == 99999) {
3728                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3729                         goto out;
3730                 }
3731
3732                 try {
3733                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3734                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
3735                 }
3736
3737                 catch (failed_constructor& err) {
3738                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3739                         goto out;
3740                 }
3741
3742                 srcs.push_back (fsource);
3743         }
3744
3745         /* tell redirects that care that we are about to use a much larger blocksize */
3746
3747         need_block_size_reset = true;
3748         track.set_block_size (chunk_size);
3749
3750         /* XXX need to flush all redirects */
3751
3752         position = start;
3753         to_do = len;
3754
3755         /* create a set of reasonably-sized buffers */
3756         buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
3757         buffers.set_count (max_proc);
3758
3759         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3760                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3761                 if (afs)
3762                         afs->prepare_for_peakfile_writes ();
3763         }
3764
3765         while (to_do && !itt.cancel) {
3766
3767                 this_chunk = min (to_do, chunk_size);
3768
3769                 if (track.export_stuff (buffers, start, this_chunk, enable_processing)) {
3770                         goto out;
3771                 }
3772
3773                 uint32_t n = 0;
3774                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3775                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3776
3777                         if (afs) {
3778                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
3779                                         goto out;
3780                                 }
3781                         }
3782                 }
3783
3784                 start += this_chunk;
3785                 to_do -= this_chunk;
3786
3787                 itt.progress = (float) (1.0 - ((double) to_do / len));
3788
3789         }
3790
3791         if (!itt.cancel) {
3792
3793                 time_t now;
3794                 struct tm* xnow;
3795                 time (&now);
3796                 xnow = localtime (&now);
3797
3798                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3799                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3800
3801                         if (afs) {
3802                                 afs->update_header (position, *xnow, now);
3803                                 afs->flush_header ();
3804                         }
3805                 }
3806
3807                 /* construct a region to represent the bounced material */
3808
3809                 PropertyList plist;
3810
3811                 plist.add (Properties::start, 0);
3812                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
3813                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
3814
3815                 result = RegionFactory::create (srcs, plist);
3816
3817         }
3818
3819   out:
3820         if (!result) {
3821                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3822                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3823
3824                         if (afs) {
3825                                 afs->mark_for_remove ();
3826                         }
3827
3828                         (*src)->drop_references ();
3829                 }
3830
3831         } else {
3832                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3833                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3834
3835                         if (afs)
3836                                 afs->done_with_peakfile_writes ();
3837                 }
3838         }
3839
3840
3841         if (need_block_size_reset) {
3842                 track.set_block_size (get_block_size());
3843         }
3844
3845         unblock_processing ();
3846
3847         return result;
3848 }
3849
3850 gain_t*
3851 Session::gain_automation_buffer() const
3852 {
3853         return ProcessThread::gain_automation_buffer ();
3854 }
3855
3856 pan_t**
3857 Session::pan_automation_buffer() const
3858 {
3859         return ProcessThread::pan_automation_buffer ();
3860 }
3861
3862 BufferSet&
3863 Session::get_silent_buffers (ChanCount count)
3864 {
3865         return ProcessThread::get_silent_buffers (count);
3866 }
3867
3868 BufferSet&
3869 Session::get_scratch_buffers (ChanCount count)
3870 {
3871         return ProcessThread::get_scratch_buffers (count);
3872 }
3873
3874 BufferSet&
3875 Session::get_mix_buffers (ChanCount count)
3876 {
3877         return ProcessThread::get_mix_buffers (count);
3878 }
3879
3880 uint32_t
3881 Session::ntracks () const
3882 {
3883         uint32_t n = 0;
3884         boost::shared_ptr<RouteList> r = routes.reader ();
3885
3886         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3887                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3888                         ++n;
3889                 }
3890         }
3891
3892         return n;
3893 }
3894
3895 uint32_t
3896 Session::nbusses () const
3897 {
3898         uint32_t n = 0;
3899         boost::shared_ptr<RouteList> r = routes.reader ();
3900
3901         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3902                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
3903                         ++n;
3904                 }
3905         }
3906
3907         return n;
3908 }
3909
3910 void
3911 Session::add_automation_list(AutomationList *al)
3912 {
3913         automation_lists[al->id()] = al;
3914 }
3915
3916 void
3917 Session::sync_order_keys (std::string const & base)
3918 {
3919         if (deletion_in_progress()) {
3920                 return;
3921         }
3922
3923         if (!Config->get_sync_all_route_ordering()) {
3924                 /* leave order keys as they are */
3925                 return;
3926         }
3927
3928         boost::shared_ptr<RouteList> r = routes.reader ();
3929
3930         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3931                 (*i)->sync_order_keys (base);
3932         }
3933
3934         Route::SyncOrderKeys (base); // EMIT SIGNAL
3935
3936         /* this might not do anything */
3937
3938         set_remote_control_ids ();
3939 }
3940
3941 /** @return true if there is at least one record-enabled track, otherwise false */
3942 bool
3943 Session::have_rec_enabled_track () const
3944 {
3945         return g_atomic_int_get (&_have_rec_enabled_track) == 1;
3946 }
3947
3948 /** Update the state of our rec-enabled tracks flag */
3949 void
3950 Session::update_have_rec_enabled_track ()
3951 {
3952         boost::shared_ptr<RouteList> rl = routes.reader ();
3953         RouteList::iterator i = rl->begin();
3954         while (i != rl->end ()) {
3955
3956                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3957                 if (tr && tr->record_enabled ()) {
3958                         break;
3959                 }
3960
3961                 ++i;
3962         }
3963
3964         int const old = g_atomic_int_get (&_have_rec_enabled_track);
3965
3966         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
3967
3968         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
3969                 RecordStateChanged (); /* EMIT SIGNAL */
3970         }
3971 }
3972
3973 void
3974 Session::listen_position_changed ()
3975 {
3976         boost::shared_ptr<RouteList> r = routes.reader ();
3977
3978         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3979                 (*i)->listen_position_changed ();
3980         }
3981 }
3982
3983 void
3984 Session::solo_control_mode_changed ()
3985 {
3986         /* cancel all solo or all listen when solo control mode changes */
3987
3988         if (soloing()) {
3989                 set_solo (get_routes(), false);
3990         } else if (listening()) {
3991                 set_listen (get_routes(), false);
3992         }
3993 }
3994
3995 /** Called when anything about any of our route groups changes (membership, state etc.) */
3996 void
3997 Session::route_group_changed ()
3998 {
3999         RouteGroupChanged (); /* EMIT SIGNAL */
4000 }
4001
4002 vector<SyncSource>
4003 Session::get_available_sync_options () const
4004 {
4005         vector<SyncSource> ret;
4006
4007         ret.push_back (JACK);
4008         ret.push_back (MTC);
4009         ret.push_back (MIDIClock);
4010
4011         return ret;
4012 }
4013
4014 boost::shared_ptr<RouteList>
4015 Session::get_routes_with_regions_at (framepos_t const p) const
4016 {
4017         boost::shared_ptr<RouteList> r = routes.reader ();
4018         boost::shared_ptr<RouteList> rl (new RouteList);
4019
4020         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4021                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4022                 if (!tr) {
4023                         continue;
4024                 }
4025
4026                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4027                 if (!pl) {
4028                         continue;
4029                 }
4030
4031                 if (pl->has_region_at (p)) {
4032                         rl->push_back (*i);
4033                 }
4034         }
4035
4036         return rl;
4037 }
4038
4039 void
4040 Session::goto_end ()
4041 {
4042         if (_session_range_location) {
4043                 request_locate (_session_range_location->end(), false);
4044         } else {
4045                 request_locate (0, false);
4046         }
4047 }
4048
4049 void
4050 Session::goto_start ()
4051 {
4052         if (_session_range_location) {
4053                 request_locate (_session_range_location->start(), false);
4054         } else {
4055                 request_locate (0, false);
4056         }
4057 }
4058
4059 framepos_t
4060 Session::current_start_frame () const
4061 {
4062         return _session_range_location ? _session_range_location->start() : 0;
4063 }
4064
4065 framepos_t
4066 Session::current_end_frame () const
4067 {
4068         return _session_range_location ? _session_range_location->end() : 0;
4069 }
4070
4071 void
4072 Session::add_session_range_location (framepos_t start, framepos_t end)
4073 {
4074         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4075         _locations->add (_session_range_location);
4076 }
4077
4078 /** Called when one of our routes' order keys has changed */
4079 void
4080 Session::route_order_key_changed ()
4081 {
4082         RouteOrderKeyChanged (); /* EMIT SIGNAL */
4083 }
4084
4085 void
4086 Session::step_edit_status_change (bool yn)
4087 {
4088         bool send = false;
4089
4090         bool val = false;
4091         if (yn) {
4092                 send = (_step_editors == 0);
4093                 val = true;
4094
4095                 _step_editors++;
4096         } else {
4097                 send = (_step_editors == 1);
4098                 val = false;
4099
4100                 if (_step_editors > 0) {
4101                         _step_editors--;
4102                 }
4103         }
4104
4105         if (send) {
4106                 StepEditStatusChange (val);
4107         }
4108 }
4109
4110
4111 void
4112 Session::start_time_changed (framepos_t old)
4113 {
4114         /* Update the auto loop range to match the session range
4115            (unless the auto loop range has been changed by the user)
4116         */
4117
4118         Location* s = _locations->session_range_location ();
4119         if (s == 0) {
4120                 return;
4121         }
4122
4123         Location* l = _locations->auto_loop_location ();
4124
4125         if (l->start() == old) {
4126                 l->set_start (s->start(), true);
4127         }
4128 }
4129
4130 void
4131 Session::end_time_changed (framepos_t old)
4132 {
4133         /* Update the auto loop range to match the session range
4134            (unless the auto loop range has been changed by the user)
4135         */
4136
4137         Location* s = _locations->session_range_location ();
4138         if (s == 0) {
4139                 return;
4140         }
4141
4142         Location* l = _locations->auto_loop_location ();
4143
4144         if (l->end() == old) {
4145                 l->set_end (s->end(), true);
4146         }
4147 }
4148
4149 string
4150 Session::source_search_path (DataType type) const
4151 {
4152         string search_path;
4153
4154         if (session_dirs.size() == 1) {
4155                 switch (type) {
4156                 case DataType::AUDIO:
4157                         search_path = _session_dir->sound_path().to_string();
4158                         break;
4159                 case DataType::MIDI:
4160                         search_path = _session_dir->midi_path().to_string();
4161                         break;
4162                 }
4163         } else {
4164                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4165                         SessionDirectory sdir (i->path);
4166                         if (!search_path.empty()) {
4167                                 search_path += ':';
4168                         }
4169                         switch (type) {
4170                         case DataType::AUDIO:
4171                                 search_path += sdir.sound_path().to_string();
4172                                 break;
4173                         case DataType::MIDI:
4174                                 search_path += sdir.midi_path().to_string();
4175                                 break;
4176                         }
4177                 }
4178         }
4179
4180         /* now add user-specified locations
4181          */
4182
4183         vector<string> dirs;
4184
4185         switch (type) {
4186         case DataType::AUDIO:
4187                 split (config.get_audio_search_path (), dirs, ':');
4188                 break;
4189         case DataType::MIDI:
4190                 split (config.get_midi_search_path (), dirs, ':');
4191                 break;
4192         }
4193
4194         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4195                 search_path += ':';
4196                 search_path += *i;
4197
4198         }
4199
4200         return search_path;
4201 }
4202
4203 void
4204 Session::ensure_search_path_includes (const string& path, DataType type)
4205 {
4206         string search_path;
4207         vector<string> dirs;
4208
4209         if (path == ".") {
4210                 return;
4211         }
4212
4213         switch (type) {
4214         case DataType::AUDIO:
4215                 search_path = config.get_audio_search_path ();
4216                 break;
4217         case DataType::MIDI:
4218                 search_path = config.get_midi_search_path ();
4219                 break;
4220         }
4221
4222         split (search_path, dirs, ':');
4223
4224         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4225                 if (*i == path) {
4226                         return;
4227                 }
4228         }
4229
4230         if (!search_path.empty()) {
4231                 search_path += ':';
4232         }
4233
4234         search_path += path;
4235
4236         switch (type) {
4237         case DataType::AUDIO:
4238                 config.set_audio_search_path (search_path);
4239                 break;
4240         case DataType::MIDI:
4241                 config.set_midi_search_path (search_path);
4242                 break;
4243         }
4244 }
4245
4246 boost::shared_ptr<Speakers>
4247 Session::get_speakers()
4248 {
4249         return _speakers;
4250 }
4251
4252 list<string>
4253 Session::unknown_processors () const
4254 {
4255         list<string> p;
4256
4257         boost::shared_ptr<RouteList> r = routes.reader ();
4258         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4259                 list<string> t = (*i)->unknown_processors ();
4260                 copy (t.begin(), t.end(), back_inserter (p));
4261         }
4262
4263         p.sort ();
4264         p.unique ();
4265
4266         return p;
4267 }
4268
4269 void
4270 Session::update_latency (bool playback)
4271 {
4272         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4273
4274         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4275                 return;
4276         }
4277
4278         boost::shared_ptr<RouteList> r = routes.reader ();
4279         framecnt_t max_latency = 0;
4280
4281         if (playback) {
4282                 /* reverse the list so that we work backwards from the last route to run to the first */
4283                 reverse (r->begin(), r->end());
4284         }
4285
4286         /* compute actual latency values for the given direction and store them all in per-port
4287            structures. this will also publish the same values (to JACK) so that computation of latency
4288            for routes can consistently use public latency values.
4289         */
4290
4291         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4292                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4293         }
4294
4295         /* because we latency compensate playback, our published playback latencies should
4296            be the same for all output ports - all material played back by ardour has
4297            the same latency, whether its caused by plugins or by latency compensation. since
4298            these may differ from the values computed above, reset all playback port latencies
4299            to the same value.
4300         */
4301
4302         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4303
4304         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4305                 (*i)->set_public_port_latencies (max_latency, playback);
4306         }
4307
4308         if (playback) {
4309
4310                 post_playback_latency ();
4311
4312         } else {
4313
4314                 post_capture_latency ();
4315         }
4316
4317         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4318 }
4319
4320 void
4321 Session::post_playback_latency ()
4322 {
4323         set_worst_playback_latency ();
4324
4325         boost::shared_ptr<RouteList> r = routes.reader ();
4326         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4327                 if (!(*i)->is_hidden() && ((*i)->active())) {
4328                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4329                 }
4330
4331                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4332                         (*i)->set_latency_compensation (_worst_track_latency);
4333                 }
4334         }
4335 }
4336
4337 void
4338 Session::post_capture_latency ()
4339 {
4340         set_worst_capture_latency ();
4341
4342         /* reflect any changes in capture latencies into capture offsets
4343          */
4344
4345         boost::shared_ptr<RouteList> rl = routes.reader();
4346         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4347                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4348                 if (tr) {
4349                         tr->set_capture_offset ();
4350                 }
4351         }
4352 }
4353
4354 void
4355 Session::set_worst_io_latencies ()
4356 {
4357         set_worst_playback_latency ();
4358         set_worst_capture_latency ();
4359 }
4360
4361 void
4362 Session::set_worst_playback_latency ()
4363 {
4364         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4365                 return;
4366         }
4367
4368         _worst_output_latency = 0;
4369
4370         if (!_engine.connected()) {
4371                 return;
4372         }
4373
4374         boost::shared_ptr<RouteList> r = routes.reader ();
4375
4376         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4377                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4378         }
4379
4380         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4381 }
4382
4383 void
4384 Session::set_worst_capture_latency ()
4385 {
4386         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4387                 return;
4388         }
4389
4390         _worst_input_latency = 0;
4391
4392         if (!_engine.connected()) {
4393                 return;
4394         }
4395
4396         boost::shared_ptr<RouteList> r = routes.reader ();
4397
4398         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4399                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4400         }
4401
4402         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4403 }
4404
4405 void
4406 Session::update_latency_compensation (bool force_whole_graph)
4407 {
4408         bool some_track_latency_changed = false;
4409
4410         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4411                 return;
4412         }
4413
4414         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4415
4416         _worst_track_latency = 0;
4417
4418         boost::shared_ptr<RouteList> r = routes.reader ();
4419
4420         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4421                 if (!(*i)->is_hidden() && ((*i)->active())) {
4422                         framecnt_t tl;
4423                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4424                                 some_track_latency_changed = true;
4425                         }
4426                         _worst_track_latency = max (tl, _worst_track_latency);
4427                 }
4428         }
4429
4430         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4431                                                      (some_track_latency_changed ? "yes" : "no")));
4432
4433         if (force_whole_graph || some_track_latency_changed) {
4434                 /* trigger a full recompute of latency numbers for the graph.
4435                    everything else that we need to do will be done in the latency
4436                    callback.
4437                 */
4438                 _engine.update_total_latencies ();
4439                 return; // everything else will be done in the latency callback
4440         }
4441
4442         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n")
4443 }
4444