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-Place */
 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         assert (pending_audition_region);
3423         auditioner->audition_region (pending_audition_region);
3424         pending_audition_region.reset ();
3425         AuditionActive (true); /* EMIT SIGNAL */
3426 }
3427
3428 void
3429 Session::audition_region (boost::shared_ptr<Region> r)
3430 {
3431         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3432         ev->region = r;
3433         queue_event (ev);
3434 }
3435
3436 void
3437 Session::cancel_audition ()
3438 {
3439         if (auditioner->auditioning()) {
3440                 auditioner->cancel_audition ();
3441                 AuditionActive (false); /* EMIT SIGNAL */
3442         }
3443 }
3444
3445 bool
3446 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3447 {
3448         if (a->is_monitor()) {
3449                 return true;
3450         }
3451         if (b->is_monitor()) {
3452                 return false;
3453         }
3454         return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3455 }
3456
3457 bool
3458 Session::is_auditioning () const
3459 {
3460         /* can be called before we have an auditioner object */
3461         if (auditioner) {
3462                 return auditioner->auditioning();
3463         } else {
3464                 return false;
3465         }
3466 }
3467
3468 void
3469 Session::graph_reordered ()
3470 {
3471         /* don't do this stuff if we are setting up connections
3472            from a set_state() call or creating new tracks. Ditto for deletion.
3473         */
3474
3475         if (_state_of_the_state & (InitialConnecting|Deletion)) {
3476                 return;
3477         }
3478
3479         /* every track/bus asked for this to be handled but it was deferred because
3480            we were connecting. do it now.
3481         */
3482
3483         request_input_change_handling ();
3484
3485         resort_routes ();
3486
3487         /* force all diskstreams to update their capture offset values to
3488            reflect any changes in latencies within the graph.
3489         */
3490
3491         boost::shared_ptr<RouteList> rl = routes.reader ();
3492         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3493                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3494                 if (tr) {
3495                         tr->set_capture_offset ();
3496                 }
3497         }
3498 }
3499
3500 framecnt_t
3501 Session::available_capture_duration ()
3502 {
3503         float sample_bytes_on_disk = 4.0; // keep gcc happy
3504
3505         switch (config.get_native_file_data_format()) {
3506         case FormatFloat:
3507                 sample_bytes_on_disk = 4.0;
3508                 break;
3509
3510         case FormatInt24:
3511                 sample_bytes_on_disk = 3.0;
3512                 break;
3513
3514         case FormatInt16:
3515                 sample_bytes_on_disk = 2.0;
3516                 break;
3517
3518         default:
3519                 /* impossible, but keep some gcc versions happy */
3520                 fatal << string_compose (_("programming error: %1"),
3521                                          X_("illegal native file data format"))
3522                       << endmsg;
3523                 /*NOTREACHED*/
3524         }
3525
3526         double scale = 4096.0 / sample_bytes_on_disk;
3527
3528         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3529                 return max_framecnt;
3530         }
3531
3532         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3533 }
3534
3535 void
3536 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3537 {
3538         {
3539                 RCUWriter<BundleList> writer (_bundles);
3540                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3541                 b->push_back (bundle);
3542         }
3543
3544         BundleAdded (bundle); /* EMIT SIGNAL */
3545
3546         set_dirty();
3547 }
3548
3549 void
3550 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3551 {
3552         bool removed = false;
3553
3554         {
3555                 RCUWriter<BundleList> writer (_bundles);
3556                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3557                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3558
3559                 if (i != b->end()) {
3560                         b->erase (i);
3561                         removed = true;
3562                 }
3563         }
3564
3565         if (removed) {
3566                  BundleRemoved (bundle); /* EMIT SIGNAL */
3567         }
3568
3569         set_dirty();
3570 }
3571
3572 boost::shared_ptr<Bundle>
3573 Session::bundle_by_name (string name) const
3574 {
3575         boost::shared_ptr<BundleList> b = _bundles.reader ();
3576
3577         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3578                 if ((*i)->name() == name) {
3579                         return* i;
3580                 }
3581         }
3582
3583         return boost::shared_ptr<Bundle> ();
3584 }
3585
3586 void
3587 Session::tempo_map_changed (const PropertyChange&)
3588 {
3589         clear_clicks ();
3590
3591         playlists->update_after_tempo_map_change ();
3592
3593         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3594
3595         set_dirty ();
3596 }
3597
3598 void
3599 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3600 {
3601         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3602                 (*i)->recompute_frames_from_bbt ();
3603         }
3604 }
3605
3606 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3607  * the given count with the current block size.
3608  */
3609 void
3610 Session::ensure_buffers (ChanCount howmany)
3611 {
3612         BufferManager::ensure_buffers (howmany);
3613 }
3614
3615 void
3616 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3617 {
3618         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3619                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3620         }
3621 }
3622
3623 uint32_t
3624 Session::next_insert_id ()
3625 {
3626         /* this doesn't really loop forever. just think about it */
3627
3628         while (true) {
3629                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3630                         if (!insert_bitset[n]) {
3631                                 insert_bitset[n] = true;
3632                                 return n;
3633
3634                         }
3635                 }
3636
3637                 /* none available, so resize and try again */
3638
3639                 insert_bitset.resize (insert_bitset.size() + 16, false);
3640         }
3641 }
3642
3643 uint32_t
3644 Session::next_send_id ()
3645 {
3646         /* this doesn't really loop forever. just think about it */
3647
3648         while (true) {
3649                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3650                         if (!send_bitset[n]) {
3651                                 send_bitset[n] = true;
3652                                 return n;
3653
3654                         }
3655                 }
3656
3657                 /* none available, so resize and try again */
3658
3659                 send_bitset.resize (send_bitset.size() + 16, false);
3660         }
3661 }
3662
3663 uint32_t
3664 Session::next_aux_send_id ()
3665 {
3666         /* this doesn't really loop forever. just think about it */
3667
3668         while (true) {
3669                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3670                         if (!aux_send_bitset[n]) {
3671                                 aux_send_bitset[n] = true;
3672                                 return n;
3673
3674                         }
3675                 }
3676
3677                 /* none available, so resize and try again */
3678
3679                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3680         }
3681 }
3682
3683 uint32_t
3684 Session::next_return_id ()
3685 {
3686         /* this doesn't really loop forever. just think about it */
3687
3688         while (true) {
3689                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3690                         if (!return_bitset[n]) {
3691                                 return_bitset[n] = true;
3692                                 return n;
3693
3694                         }
3695                 }
3696
3697                 /* none available, so resize and try again */
3698
3699                 return_bitset.resize (return_bitset.size() + 16, false);
3700         }
3701 }
3702
3703 void
3704 Session::mark_send_id (uint32_t id)
3705 {
3706         if (id >= send_bitset.size()) {
3707                 send_bitset.resize (id+16, false);
3708         }
3709         if (send_bitset[id]) {
3710                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3711         }
3712         send_bitset[id] = true;
3713 }
3714
3715 void
3716 Session::mark_aux_send_id (uint32_t id)
3717 {
3718         if (id >= aux_send_bitset.size()) {
3719                 aux_send_bitset.resize (id+16, false);
3720         }
3721         if (aux_send_bitset[id]) {
3722                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3723         }
3724         aux_send_bitset[id] = true;
3725 }
3726
3727 void
3728 Session::mark_return_id (uint32_t id)
3729 {
3730         if (id >= return_bitset.size()) {
3731                 return_bitset.resize (id+16, false);
3732         }
3733         if (return_bitset[id]) {
3734                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3735         }
3736         return_bitset[id] = true;
3737 }
3738
3739 void
3740 Session::mark_insert_id (uint32_t id)
3741 {
3742         if (id >= insert_bitset.size()) {
3743                 insert_bitset.resize (id+16, false);
3744         }
3745         if (insert_bitset[id]) {
3746                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3747         }
3748         insert_bitset[id] = true;
3749 }
3750
3751 void
3752 Session::unmark_send_id (uint32_t id)
3753 {
3754         if (id < send_bitset.size()) {
3755                 send_bitset[id] = false;
3756         }
3757 }
3758
3759 void
3760 Session::unmark_aux_send_id (uint32_t id)
3761 {
3762         if (id < aux_send_bitset.size()) {
3763                 aux_send_bitset[id] = false;
3764         }
3765 }
3766
3767 void
3768 Session::unmark_return_id (uint32_t id)
3769 {
3770         if (id < return_bitset.size()) {
3771                 return_bitset[id] = false;
3772         }
3773 }
3774
3775 void
3776 Session::unmark_insert_id (uint32_t id)
3777 {
3778         if (id < insert_bitset.size()) {
3779                 insert_bitset[id] = false;
3780         }
3781 }
3782
3783
3784 /* Named Selection management */
3785
3786 boost::shared_ptr<NamedSelection>
3787 Session::named_selection_by_name (string name)
3788 {
3789         Glib::Mutex::Lock lm (named_selection_lock);
3790         for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3791                 if ((*i)->name == name) {
3792                         return *i;
3793                 }
3794         }
3795         return boost::shared_ptr<NamedSelection>();
3796 }
3797
3798 void
3799 Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3800 {
3801         {
3802                 Glib::Mutex::Lock lm (named_selection_lock);
3803                 named_selections.insert (named_selections.begin(), named_selection);
3804         }
3805
3806         set_dirty();
3807
3808         NamedSelectionAdded (); /* EMIT SIGNAL */
3809 }
3810
3811 void
3812 Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3813 {
3814         bool removed = false;
3815
3816         {
3817                 Glib::Mutex::Lock lm (named_selection_lock);
3818
3819                 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3820
3821                 if (i != named_selections.end()) {
3822                         named_selections.erase (i);
3823                         set_dirty();
3824                         removed = true;
3825                 }
3826         }
3827
3828         if (removed) {
3829                  NamedSelectionRemoved (); /* EMIT SIGNAL */
3830         }
3831 }
3832
3833 void
3834 Session::reset_native_file_format ()
3835 {
3836         boost::shared_ptr<RouteList> rl = routes.reader ();
3837         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3838                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3839                 if (tr) {
3840                         /* don't save state as we do this, there's no point
3841                          */
3842
3843                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3844                         tr->reset_write_sources (false);
3845                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3846                 }
3847         }
3848 }
3849
3850 bool
3851 Session::route_name_unique (string n) const
3852 {
3853         boost::shared_ptr<RouteList> r = routes.reader ();
3854
3855         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3856                 if ((*i)->name() == n) {
3857                         return false;
3858                 }
3859         }
3860
3861         return true;
3862 }
3863
3864 bool
3865 Session::route_name_internal (string n) const
3866 {
3867         if (auditioner && auditioner->name() == n) {
3868                 return true;
3869         }
3870
3871         if (_click_io && _click_io->name() == n) {
3872                 return true;
3873         }
3874
3875         return false;
3876 }
3877
3878 int
3879 Session::freeze_all (InterThreadInfo& itt)
3880 {
3881         boost::shared_ptr<RouteList> r = routes.reader ();
3882
3883         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3884
3885                 boost::shared_ptr<Track> t;
3886
3887                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3888                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3889                            of every track.
3890                         */
3891                         t->freeze_me (itt);
3892                 }
3893         }
3894
3895         return 0;
3896 }
3897
3898 boost::shared_ptr<Region>
3899 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3900                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3901                           InterThreadInfo& itt,
3902                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
3903                           bool for_export)
3904 {
3905         boost::shared_ptr<Region> result;
3906         boost::shared_ptr<Playlist> playlist;
3907         boost::shared_ptr<AudioFileSource> fsource;
3908         uint32_t x;
3909         char buf[PATH_MAX+1];
3910         ChanCount diskstream_channels (track.n_channels());
3911         framepos_t position;
3912         framecnt_t this_chunk;
3913         framepos_t to_do;
3914         BufferSet buffers;
3915         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3916         const string sound_dir = sdir.sound_path().to_string();
3917         framepos_t len = end - start;
3918         bool need_block_size_reset = false;
3919         string ext;
3920         ChanCount const max_proc = track.max_processor_streams ();
3921
3922         if (end <= start) {
3923                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3924                                          end, start) << endmsg;
3925                 return result;
3926         }
3927
3928         const framecnt_t chunk_size = (256 * 1024)/4;
3929
3930         // block all process callback handling
3931
3932         block_processing ();
3933
3934         /* call tree *MUST* hold route_lock */
3935
3936         if ((playlist = track.playlist()) == 0) {
3937                 goto out;
3938         }
3939
3940         ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3941
3942         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3943
3944                 for (x = 0; x < 99999; ++x) {
3945                         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());
3946                         if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3947                                 break;
3948                         }
3949                 }
3950
3951                 if (x == 99999) {
3952                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3953                         goto out;
3954                 }
3955
3956                 try {
3957                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3958                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
3959                 }
3960
3961                 catch (failed_constructor& err) {
3962                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3963                         goto out;
3964                 }
3965
3966                 srcs.push_back (fsource);
3967         }
3968
3969         /* tell redirects that care that we are about to use a much larger
3970          * blocksize. this will flush all plugins too, so that they are ready
3971          * to be used for this process.
3972          */
3973
3974         need_block_size_reset = true;
3975         track.set_block_size (chunk_size);
3976
3977         position = start;
3978         to_do = len;
3979
3980         /* create a set of reasonably-sized buffers */
3981         buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
3982         buffers.set_count (max_proc);
3983
3984         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3985                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3986                 if (afs)
3987                         afs->prepare_for_peakfile_writes ();
3988         }
3989
3990         while (to_do && !itt.cancel) {
3991
3992                 this_chunk = min (to_do, chunk_size);
3993
3994                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
3995                         goto out;
3996                 }
3997
3998                 uint32_t n = 0;
3999                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4000                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4001
4002                         if (afs) {
4003                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4004                                         goto out;
4005                                 }
4006                         }
4007                 }
4008
4009                 start += this_chunk;
4010                 to_do -= this_chunk;
4011
4012                 itt.progress = (float) (1.0 - ((double) to_do / len));
4013
4014         }
4015
4016         if (!itt.cancel) {
4017
4018                 time_t now;
4019                 struct tm* xnow;
4020                 time (&now);
4021                 xnow = localtime (&now);
4022
4023                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4024                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4025
4026                         if (afs) {
4027                                 afs->update_header (position, *xnow, now);
4028                                 afs->flush_header ();
4029                         }
4030                 }
4031
4032                 /* construct a region to represent the bounced material */
4033
4034                 PropertyList plist;
4035
4036                 plist.add (Properties::start, 0);
4037                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4038                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4039
4040                 result = RegionFactory::create (srcs, plist);
4041
4042         }
4043
4044   out:
4045         if (!result) {
4046                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4047                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4048
4049                         if (afs) {
4050                                 afs->mark_for_remove ();
4051                         }
4052
4053                         (*src)->drop_references ();
4054                 }
4055
4056         } else {
4057                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4058                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4059
4060                         if (afs)
4061                                 afs->done_with_peakfile_writes ();
4062                 }
4063         }
4064
4065
4066         if (need_block_size_reset) {
4067                 track.set_block_size (get_block_size());
4068         }
4069
4070         unblock_processing ();
4071
4072         return result;
4073 }
4074
4075 gain_t*
4076 Session::gain_automation_buffer() const
4077 {
4078         return ProcessThread::gain_automation_buffer ();
4079 }
4080
4081 pan_t**
4082 Session::pan_automation_buffer() const
4083 {
4084         return ProcessThread::pan_automation_buffer ();
4085 }
4086
4087 BufferSet&
4088 Session::get_silent_buffers (ChanCount count)
4089 {
4090         return ProcessThread::get_silent_buffers (count);
4091 }
4092
4093 BufferSet&
4094 Session::get_scratch_buffers (ChanCount count)
4095 {
4096         return ProcessThread::get_scratch_buffers (count);
4097 }
4098
4099 BufferSet&
4100 Session::get_mix_buffers (ChanCount count)
4101 {
4102         return ProcessThread::get_mix_buffers (count);
4103 }
4104
4105 uint32_t
4106 Session::ntracks () const
4107 {
4108         uint32_t n = 0;
4109         boost::shared_ptr<RouteList> r = routes.reader ();
4110
4111         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4112                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4113                         ++n;
4114                 }
4115         }
4116
4117         return n;
4118 }
4119
4120 uint32_t
4121 Session::nbusses () const
4122 {
4123         uint32_t n = 0;
4124         boost::shared_ptr<RouteList> r = routes.reader ();
4125
4126         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4127                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4128                         ++n;
4129                 }
4130         }
4131
4132         return n;
4133 }
4134
4135 void
4136 Session::add_automation_list(AutomationList *al)
4137 {
4138         automation_lists[al->id()] = al;
4139 }
4140
4141 void
4142 Session::sync_order_keys (std::string const & base)
4143 {
4144         if (deletion_in_progress()) {
4145                 return;
4146         }
4147
4148         if (!Config->get_sync_all_route_ordering()) {
4149                 /* leave order keys as they are */
4150                 return;
4151         }
4152
4153         boost::shared_ptr<RouteList> r = routes.reader ();
4154
4155         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4156                 (*i)->sync_order_keys (base);
4157         }
4158
4159         Route::SyncOrderKeys (base); // EMIT SIGNAL
4160
4161         /* this might not do anything */
4162
4163         set_remote_control_ids ();
4164 }
4165
4166 /** @return true if there is at least one record-enabled track, otherwise false */
4167 bool
4168 Session::have_rec_enabled_track () const
4169 {
4170         return g_atomic_int_get (&_have_rec_enabled_track) == 1;
4171 }
4172
4173 /** Update the state of our rec-enabled tracks flag */
4174 void
4175 Session::update_have_rec_enabled_track ()
4176 {
4177         boost::shared_ptr<RouteList> rl = routes.reader ();
4178         RouteList::iterator i = rl->begin();
4179         while (i != rl->end ()) {
4180
4181                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4182                 if (tr && tr->record_enabled ()) {
4183                         break;
4184                 }
4185
4186                 ++i;
4187         }
4188
4189         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4190
4191         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4192
4193         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4194                 RecordStateChanged (); /* EMIT SIGNAL */
4195         }
4196 }
4197
4198 void
4199 Session::listen_position_changed ()
4200 {
4201         boost::shared_ptr<RouteList> r = routes.reader ();
4202
4203         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4204                 (*i)->listen_position_changed ();
4205         }
4206 }
4207
4208 void
4209 Session::solo_control_mode_changed ()
4210 {
4211         /* cancel all solo or all listen when solo control mode changes */
4212
4213         if (soloing()) {
4214                 set_solo (get_routes(), false);
4215         } else if (listening()) {
4216                 set_listen (get_routes(), false);
4217         }
4218 }
4219
4220 /** Called when a property of one of our route groups changes */
4221 void
4222 Session::route_group_property_changed (RouteGroup* rg)
4223 {
4224         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4225 }
4226
4227 /** Called when a route is added to one of our route groups */
4228 void
4229 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4230 {
4231         RouteAddedToRouteGroup (rg, r);
4232 }
4233
4234 /** Called when a route is removed from one of our route groups */
4235 void
4236 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4237 {
4238         RouteRemovedFromRouteGroup (rg, r);
4239 }
4240
4241 vector<SyncSource>
4242 Session::get_available_sync_options () const
4243 {
4244         vector<SyncSource> ret;
4245
4246         ret.push_back (JACK);
4247         ret.push_back (MTC);
4248         ret.push_back (MIDIClock);
4249
4250         return ret;
4251 }
4252
4253 boost::shared_ptr<RouteList>
4254 Session::get_routes_with_regions_at (framepos_t const p) const
4255 {
4256         boost::shared_ptr<RouteList> r = routes.reader ();
4257         boost::shared_ptr<RouteList> rl (new RouteList);
4258
4259         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4260                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4261                 if (!tr) {
4262                         continue;
4263                 }
4264
4265                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4266                 if (!pl) {
4267                         continue;
4268                 }
4269
4270                 if (pl->has_region_at (p)) {
4271                         rl->push_back (*i);
4272                 }
4273         }
4274
4275         return rl;
4276 }
4277
4278 void
4279 Session::goto_end ()
4280 {
4281         if (_session_range_location) {
4282                 request_locate (_session_range_location->end(), false);
4283         } else {
4284                 request_locate (0, false);
4285         }
4286 }
4287
4288 void
4289 Session::goto_start ()
4290 {
4291         if (_session_range_location) {
4292                 request_locate (_session_range_location->start(), false);
4293         } else {
4294                 request_locate (0, false);
4295         }
4296 }
4297
4298 framepos_t
4299 Session::current_start_frame () const
4300 {
4301         return _session_range_location ? _session_range_location->start() : 0;
4302 }
4303
4304 framepos_t
4305 Session::current_end_frame () const
4306 {
4307         return _session_range_location ? _session_range_location->end() : 0;
4308 }
4309
4310 void
4311 Session::add_session_range_location (framepos_t start, framepos_t end)
4312 {
4313         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4314         _locations->add (_session_range_location);
4315 }
4316
4317 /** Called when one of our routes' order keys has changed */
4318 void
4319 Session::route_order_key_changed ()
4320 {
4321         RouteOrderKeyChanged (); /* EMIT SIGNAL */
4322 }
4323
4324 void
4325 Session::step_edit_status_change (bool yn)
4326 {
4327         bool send = false;
4328
4329         bool val = false;
4330         if (yn) {
4331                 send = (_step_editors == 0);
4332                 val = true;
4333
4334                 _step_editors++;
4335         } else {
4336                 send = (_step_editors == 1);
4337                 val = false;
4338
4339                 if (_step_editors > 0) {
4340                         _step_editors--;
4341                 }
4342         }
4343
4344         if (send) {
4345                 StepEditStatusChange (val);
4346         }
4347 }
4348
4349
4350 void
4351 Session::start_time_changed (framepos_t old)
4352 {
4353         /* Update the auto loop range to match the session range
4354            (unless the auto loop range has been changed by the user)
4355         */
4356
4357         Location* s = _locations->session_range_location ();
4358         if (s == 0) {
4359                 return;
4360         }
4361
4362         Location* l = _locations->auto_loop_location ();
4363
4364         if (l && l->start() == old) {
4365                 l->set_start (s->start(), true);
4366         }
4367 }
4368
4369 void
4370 Session::end_time_changed (framepos_t old)
4371 {
4372         /* Update the auto loop range to match the session range
4373            (unless the auto loop range has been changed by the user)
4374         */
4375
4376         Location* s = _locations->session_range_location ();
4377         if (s == 0) {
4378                 return;
4379         }
4380
4381         Location* l = _locations->auto_loop_location ();
4382
4383         if (l && l->end() == old) {
4384                 l->set_end (s->end(), true);
4385         }
4386 }
4387
4388 string
4389 Session::source_search_path (DataType type) const
4390 {
4391         vector<string> s;
4392
4393         if (session_dirs.size() == 1) {
4394                 switch (type) {
4395                 case DataType::AUDIO:
4396                         s.push_back ( _session_dir->sound_path().to_string());
4397                         break;
4398                 case DataType::MIDI:
4399                         s.push_back (_session_dir->midi_path().to_string());
4400                         break;
4401                 }
4402         } else {
4403                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4404                         SessionDirectory sdir (i->path);
4405                         switch (type) {
4406                         case DataType::AUDIO:
4407                                 s.push_back (sdir.sound_path().to_string());
4408                                 break;
4409                         case DataType::MIDI:
4410                                 s.push_back (sdir.midi_path().to_string());
4411                                 break;
4412                         }
4413                 }
4414         }
4415
4416         /* now check the explicit (possibly user-specified) search path
4417          */
4418
4419         vector<string> dirs;
4420
4421         switch (type) {
4422         case DataType::AUDIO:
4423                 split (config.get_audio_search_path (), dirs, ':');
4424                 break;
4425         case DataType::MIDI:
4426                 split (config.get_midi_search_path (), dirs, ':');
4427                 break;
4428         }
4429
4430         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4431
4432                 vector<string>::iterator si;
4433
4434                 for (si = s.begin(); si != s.end(); ++si) {
4435                         if ((*si) == *i) {
4436                                 break;
4437                         }
4438                 }
4439
4440                 if (si == s.end()) {
4441                         s.push_back (*i);
4442                 }
4443         }
4444
4445         string search_path;
4446
4447         for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4448                 if (!search_path.empty()) {
4449                         search_path += ':';
4450                 }
4451                 search_path += *si;
4452         }
4453
4454         return search_path;
4455 }
4456
4457 void
4458 Session::ensure_search_path_includes (const string& path, DataType type)
4459 {
4460         string search_path;
4461         vector<string> dirs;
4462
4463         if (path == ".") {
4464                 return;
4465         }
4466
4467         switch (type) {
4468         case DataType::AUDIO:
4469                 search_path = config.get_audio_search_path ();
4470                 break;
4471         case DataType::MIDI:
4472                 search_path = config.get_midi_search_path ();
4473                 break;
4474         }
4475
4476         split (search_path, dirs, ':');
4477
4478         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4479                 /* No need to add this new directory if it has the same inode as
4480                    an existing one; checking inode rather than name prevents duplicated
4481                    directories when we are using symlinks.
4482
4483                    On Windows, I think we could just do if (*i == path) here.
4484                 */
4485                 if (inodes_same (*i, path)) {
4486                         return;
4487                 }
4488         }
4489
4490         if (!search_path.empty()) {
4491                 search_path += ':';
4492         }
4493
4494         search_path += path;
4495
4496         switch (type) {
4497         case DataType::AUDIO:
4498                 config.set_audio_search_path (search_path);
4499                 break;
4500         case DataType::MIDI:
4501                 config.set_midi_search_path (search_path);
4502                 break;
4503         }
4504 }
4505
4506 boost::shared_ptr<Speakers>
4507 Session::get_speakers()
4508 {
4509         return _speakers;
4510 }
4511
4512 list<string>
4513 Session::unknown_processors () const
4514 {
4515         list<string> p;
4516
4517         boost::shared_ptr<RouteList> r = routes.reader ();
4518         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4519                 list<string> t = (*i)->unknown_processors ();
4520                 copy (t.begin(), t.end(), back_inserter (p));
4521         }
4522
4523         p.sort ();
4524         p.unique ();
4525
4526         return p;
4527 }
4528
4529 void
4530 Session::update_latency (bool playback)
4531 {
4532         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4533
4534         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4535                 return;
4536         }
4537
4538         boost::shared_ptr<RouteList> r = routes.reader ();
4539         framecnt_t max_latency = 0;
4540
4541         if (playback) {
4542                 /* reverse the list so that we work backwards from the last route to run to the first */
4543                 RouteList* rl = routes.reader().get();
4544                 r.reset (new RouteList (*rl));
4545                 reverse (r->begin(), r->end());
4546         }
4547
4548         /* compute actual latency values for the given direction and store them all in per-port
4549            structures. this will also publish the same values (to JACK) so that computation of latency
4550            for routes can consistently use public latency values.
4551         */
4552
4553         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4554                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4555         }
4556
4557         /* because we latency compensate playback, our published playback latencies should
4558            be the same for all output ports - all material played back by ardour has
4559            the same latency, whether its caused by plugins or by latency compensation. since
4560            these may differ from the values computed above, reset all playback port latencies
4561            to the same value.
4562         */
4563
4564         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4565
4566         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4567                 (*i)->set_public_port_latencies (max_latency, playback);
4568         }
4569
4570         if (playback) {
4571
4572                 post_playback_latency ();
4573
4574         } else {
4575
4576                 post_capture_latency ();
4577         }
4578
4579         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4580 }
4581
4582 void
4583 Session::post_playback_latency ()
4584 {
4585         set_worst_playback_latency ();
4586
4587         boost::shared_ptr<RouteList> r = routes.reader ();
4588
4589         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4590                 if (!(*i)->is_hidden() && ((*i)->active())) {
4591                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4592                 }
4593         }
4594
4595         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4596                 (*i)->set_latency_compensation (_worst_track_latency);
4597         }
4598 }
4599
4600 void
4601 Session::post_capture_latency ()
4602 {
4603         set_worst_capture_latency ();
4604
4605         /* reflect any changes in capture latencies into capture offsets
4606          */
4607
4608         boost::shared_ptr<RouteList> rl = routes.reader();
4609         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4610                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4611                 if (tr) {
4612                         tr->set_capture_offset ();
4613                 }
4614         }
4615 }
4616
4617 void
4618 Session::initialize_latencies ()
4619 {
4620         {
4621                 Glib::Mutex::Lock lm (_engine.process_lock());
4622                 update_latency (false);
4623                 update_latency (true);
4624         }
4625
4626         set_worst_io_latencies ();
4627 }
4628
4629 void
4630 Session::set_worst_io_latencies ()
4631 {
4632         set_worst_playback_latency ();
4633         set_worst_capture_latency ();
4634 }
4635
4636 void
4637 Session::set_worst_playback_latency ()
4638 {
4639         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4640                 return;
4641         }
4642
4643         _worst_output_latency = 0;
4644
4645         if (!_engine.connected()) {
4646                 return;
4647         }
4648
4649         boost::shared_ptr<RouteList> r = routes.reader ();
4650
4651         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4652                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4653         }
4654
4655         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4656 }
4657
4658 void
4659 Session::set_worst_capture_latency ()
4660 {
4661         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4662                 return;
4663         }
4664
4665         _worst_input_latency = 0;
4666
4667         if (!_engine.connected()) {
4668                 return;
4669         }
4670
4671         boost::shared_ptr<RouteList> r = routes.reader ();
4672
4673         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4674                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4675         }
4676
4677         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4678 }
4679
4680 void
4681 Session::update_latency_compensation (bool force_whole_graph)
4682 {
4683         bool some_track_latency_changed = false;
4684
4685         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4686                 return;
4687         }
4688
4689         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4690
4691         _worst_track_latency = 0;
4692
4693         boost::shared_ptr<RouteList> r = routes.reader ();
4694
4695         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4696                 if (!(*i)->is_hidden() && ((*i)->active())) {
4697                         framecnt_t tl;
4698                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4699                                 some_track_latency_changed = true;
4700                         }
4701                         _worst_track_latency = max (tl, _worst_track_latency);
4702                 }
4703         }
4704
4705         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4706                                                      (some_track_latency_changed ? "yes" : "no")));
4707
4708         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4709
4710         if (some_track_latency_changed || force_whole_graph)  {
4711                 _engine.update_latencies ();
4712         }
4713
4714
4715         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4716                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4717                 if (!tr) {
4718                         continue;
4719                 }
4720                 tr->set_capture_offset ();
4721         }
4722 }
4723
4724 char
4725 Session::session_name_is_legal (const string& path)
4726 {
4727         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4728
4729         for (int i = 0; illegal_chars[i]; ++i) {
4730                 if (path.find (illegal_chars[i]) != string::npos) {
4731                         return illegal_chars[i];
4732                 }
4733         }
4734
4735         return 0;
4736 }
4737
4738 uint32_t
4739 Session::next_control_id () const
4740 {
4741         return ntracks() + nbusses() + 1;
4742 }