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