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