libs/ardour/session.cc

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