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