libs/ardour/session.cc

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