libs/ardour/session.cc

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