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