libs/ardour/session.cc

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