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