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