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