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