libs/ardour/session.cc

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