libs/ardour/session.cc

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