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