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