libs/ardour/session.cc

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