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