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