libs/ardour/session.cc

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