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