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