libs/ardour/session.cc

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