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