libs/ardour/session.cc

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