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