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