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         string basename = PBD::basename_nosuffix (name);
3513
3514         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
3515
3516                 /* note that we search *without* the extension so that
3517                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3518                    in the event that this new name is required for
3519                    a file format change.
3520                 */
3521
3522                 const string spath = *i;
3523
3524                 if (matching_unsuffixed_filename_exists_in (spath, basename)) {
3525                         existing++;
3526                         break;
3527                 }
3528
3529                 /* it is possible that we have the path already
3530                  * assigned to a source that has not yet been written
3531                  * (ie. the write source for a diskstream). we have to
3532                  * check this in order to make sure that our candidate
3533                  * path isn't used again, because that can lead to
3534                  * two Sources point to the same file with different
3535                  * notions of their removability.
3536                  */
3537
3538
3539                 string possible_path = Glib::build_filename (spath, name);
3540
3541                 if (audio_source_by_path_and_channel (possible_path, chan)) {
3542                         existing++;
3543                         break;
3544                 }
3545         }
3546
3547         return (existing == 0);
3548 }
3549
3550 string
3551 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)
3552 {
3553         ostringstream sstr;
3554         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3555
3556         if (destructive) {
3557                 sstr << 'T';
3558                 sstr << setfill ('0') << setw (4) << cnt;
3559                 sstr << legalized_base;
3560         } else {
3561                 sstr << legalized_base;
3562
3563                 if (take_required || related_exists) {
3564                         sstr << '-';
3565                         sstr << cnt;
3566                 }
3567         }
3568
3569         if (nchan == 2) {
3570                 if (chan == 0) {
3571                         sstr << "%L";
3572                 } else {
3573                         sstr << "%R";
3574                 }
3575         } else if (nchan > 2) {
3576                 if (nchan < 26) {
3577                         sstr << '%';
3578                         sstr << 'a' + chan;
3579                 } else {
3580                         /* XXX what? more than 26 channels! */
3581                         sstr << '%';
3582                         sstr << chan+1;
3583                 }
3584         }
3585
3586         sstr << ext;
3587
3588         return sstr.str();
3589 }
3590
3591 /** Return a unique name based on \a base for a new internal audio source */
3592 string
3593 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
3594 {
3595         uint32_t cnt;
3596         string possible_name;
3597         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
3598         string legalized;
3599         bool some_related_source_name_exists = false;
3600
3601         legalized = legalize_for_path (base);
3602
3603         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3604
3605         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3606
3607                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
3608
3609                 if (audio_source_name_is_unique (possible_name, chan)) {
3610                         break;
3611                 }
3612
3613                 some_related_source_name_exists = true;
3614
3615                 if (cnt > limit) {
3616                         error << string_compose(
3617                                         _("There are already %1 recordings for %2, which I consider too many."),
3618                                         limit, base) << endmsg;
3619                         destroy ();
3620                         throw failed_constructor();
3621                 }
3622         }
3623
3624         /* We've established that the new name does not exist in any session
3625          * directory, so now find out which one we should use for this new
3626          * audio source.
3627          */
3628
3629         SessionDirectory sdir (get_best_session_directory_for_new_audio());
3630
3631         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
3632
3633         return s;
3634 }
3635
3636 /** Return a unique name based on \a owner_name for a new internal MIDI source */
3637 string
3638 Session::new_midi_source_path (const string& base)
3639 {
3640         uint32_t cnt;
3641         char buf[PATH_MAX+1];
3642         const uint32_t limit = 10000;
3643         string legalized;
3644         string possible_path;
3645         string possible_name;
3646
3647         buf[0] = '\0';
3648         legalized = legalize_for_path (base);
3649
3650         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3651         std::vector<string> sdirs = source_search_path(DataType::MIDI);
3652
3653         /* - the main session folder is the first in the vector.
3654          * - after checking all locations for file-name uniqueness,
3655          *   we keep the one from the last iteration as new file name
3656          * - midi files are small and should just be kept in the main session-folder
3657          *
3658          * -> reverse the array, check main session folder last and use that as location
3659          *    for MIDI files.
3660          */
3661         std::reverse(sdirs.begin(), sdirs.end());
3662
3663         for (cnt = 1; cnt <= limit; ++cnt) {
3664
3665                 vector<space_and_path>::iterator i;
3666                 uint32_t existing = 0;
3667
3668                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
3669
3670                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
3671                         possible_name = buf;
3672
3673                         possible_path = Glib::build_filename (*i, possible_name);
3674
3675                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
3676                                 existing++;
3677                         }
3678
3679                         if (midi_source_by_path (possible_path)) {
3680                                 existing++;
3681                         }
3682                 }
3683
3684                 if (existing == 0) {
3685                         break;
3686                 }
3687
3688                 if (cnt > limit) {
3689                         error << string_compose(
3690                                         _("There are already %1 recordings for %2, which I consider too many."),
3691                                         limit, base) << endmsg;
3692                         destroy ();
3693                         return 0;
3694                 }
3695         }
3696
3697         /* No need to "find best location" for software/app-based RAID, because
3698            MIDI is so small that we always put it in the same place.
3699         */
3700
3701         return possible_path;
3702 }
3703
3704
3705 /** Create a new within-session audio source */
3706 boost::shared_ptr<AudioFileSource>
3707 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
3708 {
3709         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
3710
3711         if (!path.empty()) {
3712                 return boost::dynamic_pointer_cast<AudioFileSource> (
3713                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3714         } else {
3715                 throw failed_constructor ();
3716         }
3717 }
3718
3719 /** Create a new within-session MIDI source */
3720 boost::shared_ptr<MidiSource>
3721 Session::create_midi_source_for_session (string const & basic_name)
3722 {
3723         const string path = new_midi_source_path (basic_name);
3724
3725         if (!path.empty()) {
3726                 return boost::dynamic_pointer_cast<SMFSource> (
3727                         SourceFactory::createWritable (
3728                                 DataType::MIDI, *this, path, false, frame_rate()));
3729         } else {
3730                 throw failed_constructor ();
3731         }
3732 }
3733
3734 /** Create a new within-session MIDI source */
3735 boost::shared_ptr<MidiSource>
3736 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
3737 {
3738         /* the caller passes in the track the source will be used in,
3739            so that we can keep the numbering sane.
3740
3741            Rationale: a track with the name "Foo" that has had N
3742            captures carried out so far will ALREADY have a write source
3743            named "Foo-N+1.mid" waiting to be used for the next capture.
3744
3745            If we call new_midi_source_name() we will get "Foo-N+2". But
3746            there is no region corresponding to "Foo-N+1", so when
3747            "Foo-N+2" appears in the track, the gap presents the user
3748            with odd behaviour - why did it skip past Foo-N+1?
3749
3750            We could explain this to the user in some odd way, but
3751            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
3752            use "Foo-N+1" here.
3753
3754            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
3755         */
3756
3757         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
3758         assert (mt);
3759         std::string name = track->steal_write_source_name ();
3760
3761         if (name.empty()) {
3762                 return boost::shared_ptr<MidiSource>();
3763         }
3764
3765         const string path = new_midi_source_path (name);
3766
3767         return boost::dynamic_pointer_cast<SMFSource> (
3768                 SourceFactory::createWritable (
3769                         DataType::MIDI, *this, path, false, frame_rate()));
3770 }
3771
3772
3773 void
3774 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3775 {
3776         if (playlist->hidden()) {
3777                 return;
3778         }
3779
3780         playlists->add (playlist);
3781
3782         if (unused) {
3783                 playlist->release();
3784         }
3785
3786         set_dirty();
3787 }
3788
3789 void
3790 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3791 {
3792         if (_state_of_the_state & Deletion) {
3793                 return;
3794         }
3795
3796         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3797
3798         if (!playlist) {
3799                 return;
3800         }
3801
3802         playlists->remove (playlist);
3803
3804         set_dirty();
3805 }
3806
3807 void
3808 Session::set_audition (boost::shared_ptr<Region> r)
3809 {
3810         pending_audition_region = r;
3811         add_post_transport_work (PostTransportAudition);
3812         _butler->schedule_transport_work ();
3813 }
3814
3815 void
3816 Session::audition_playlist ()
3817 {
3818         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3819         ev->region.reset ();
3820         queue_event (ev);
3821 }
3822
3823 void
3824 Session::non_realtime_set_audition ()
3825 {
3826         assert (pending_audition_region);
3827         auditioner->audition_region (pending_audition_region);
3828         pending_audition_region.reset ();
3829         AuditionActive (true); /* EMIT SIGNAL */
3830 }
3831
3832 void
3833 Session::audition_region (boost::shared_ptr<Region> r)
3834 {
3835         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3836         ev->region = r;
3837         queue_event (ev);
3838 }
3839
3840 void
3841 Session::cancel_audition ()
3842 {
3843         if (!auditioner) {
3844                 return;
3845         }
3846         if (auditioner->auditioning()) {
3847                 auditioner->cancel_audition ();
3848                 AuditionActive (false); /* EMIT SIGNAL */
3849         }
3850 }
3851
3852 bool
3853 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3854 {
3855         if (a->is_monitor()) {
3856                 return true;
3857         }
3858         if (b->is_monitor()) {
3859                 return false;
3860         }
3861         return a->order_key () < b->order_key ();
3862 }
3863
3864 bool
3865 Session::is_auditioning () const
3866 {
3867         /* can be called before we have an auditioner object */
3868         if (auditioner) {
3869                 return auditioner->auditioning();
3870         } else {
3871                 return false;
3872         }
3873 }
3874
3875 void
3876 Session::graph_reordered ()
3877 {
3878         /* don't do this stuff if we are setting up connections
3879            from a set_state() call or creating new tracks. Ditto for deletion.
3880         */
3881
3882         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3883                 return;
3884         }
3885
3886         /* every track/bus asked for this to be handled but it was deferred because
3887            we were connecting. do it now.
3888         */
3889
3890         request_input_change_handling ();
3891
3892         resort_routes ();
3893
3894         /* force all diskstreams to update their capture offset values to
3895            reflect any changes in latencies within the graph.
3896         */
3897
3898         boost::shared_ptr<RouteList> rl = routes.reader ();
3899         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3900                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3901                 if (tr) {
3902                         tr->set_capture_offset ();
3903                 }
3904         }
3905 }
3906
3907 /** @return Number of frames that there is disk space available to write,
3908  *  if known.
3909  */
3910 boost::optional<framecnt_t>
3911 Session::available_capture_duration ()
3912 {
3913         Glib::Threads::Mutex::Lock lm (space_lock);
3914
3915         if (_total_free_4k_blocks_uncertain) {
3916                 return boost::optional<framecnt_t> ();
3917         }
3918
3919         float sample_bytes_on_disk = 4.0; // keep gcc happy
3920
3921         switch (config.get_native_file_data_format()) {
3922         case FormatFloat:
3923                 sample_bytes_on_disk = 4.0;
3924                 break;
3925
3926         case FormatInt24:
3927                 sample_bytes_on_disk = 3.0;
3928                 break;
3929
3930         case FormatInt16:
3931                 sample_bytes_on_disk = 2.0;
3932                 break;
3933
3934         default:
3935                 /* impossible, but keep some gcc versions happy */
3936                 fatal << string_compose (_("programming error: %1"),
3937                                          X_("illegal native file data format"))
3938                       << endmsg;
3939                 /*NOTREACHED*/
3940         }
3941
3942         double scale = 4096.0 / sample_bytes_on_disk;
3943
3944         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3945                 return max_framecnt;
3946         }
3947
3948         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3949 }
3950
3951 void
3952 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3953 {
3954         {
3955                 RCUWriter<BundleList> writer (_bundles);
3956                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3957                 b->push_back (bundle);
3958         }
3959
3960         BundleAdded (bundle); /* EMIT SIGNAL */
3961
3962         set_dirty();
3963 }
3964
3965 void
3966 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3967 {
3968         bool removed = false;
3969
3970         {
3971                 RCUWriter<BundleList> writer (_bundles);
3972                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3973                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3974
3975                 if (i != b->end()) {
3976                         b->erase (i);
3977                         removed = true;
3978                 }
3979         }
3980
3981         if (removed) {
3982                  BundleRemoved (bundle); /* EMIT SIGNAL */
3983         }
3984
3985         set_dirty();
3986 }
3987
3988 boost::shared_ptr<Bundle>
3989 Session::bundle_by_name (string name) const
3990 {
3991         boost::shared_ptr<BundleList> b = _bundles.reader ();
3992
3993         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3994                 if ((*i)->name() == name) {
3995                         return* i;
3996                 }
3997         }
3998
3999         return boost::shared_ptr<Bundle> ();
4000 }
4001
4002 void
4003 Session::tempo_map_changed (const PropertyChange&)
4004 {
4005         clear_clicks ();
4006
4007         playlists->update_after_tempo_map_change ();
4008
4009         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4010
4011         set_dirty ();
4012 }
4013
4014 void
4015 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
4016 {
4017         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
4018                 (*i)->recompute_frames_from_bbt ();
4019         }
4020 }
4021
4022 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4023  * the given count with the current block size.
4024  */
4025 void
4026 Session::ensure_buffers (ChanCount howmany)
4027 {
4028         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4029 }
4030
4031 void
4032 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4033 {
4034         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4035                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4036         }
4037 }
4038
4039 uint32_t
4040 Session::next_insert_id ()
4041 {
4042         /* this doesn't really loop forever. just think about it */
4043
4044         while (true) {
4045                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4046                         if (!insert_bitset[n]) {
4047                                 insert_bitset[n] = true;
4048                                 return n;
4049
4050                         }
4051                 }
4052
4053                 /* none available, so resize and try again */
4054
4055                 insert_bitset.resize (insert_bitset.size() + 16, false);
4056         }
4057 }
4058
4059 uint32_t
4060 Session::next_send_id ()
4061 {
4062         /* this doesn't really loop forever. just think about it */
4063
4064         while (true) {
4065                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4066                         if (!send_bitset[n]) {
4067                                 send_bitset[n] = true;
4068                                 return n;
4069
4070                         }
4071                 }
4072
4073                 /* none available, so resize and try again */
4074
4075                 send_bitset.resize (send_bitset.size() + 16, false);
4076         }
4077 }
4078
4079 uint32_t
4080 Session::next_aux_send_id ()
4081 {
4082         /* this doesn't really loop forever. just think about it */
4083
4084         while (true) {
4085                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4086                         if (!aux_send_bitset[n]) {
4087                                 aux_send_bitset[n] = true;
4088                                 return n;
4089
4090                         }
4091                 }
4092
4093                 /* none available, so resize and try again */
4094
4095                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4096         }
4097 }
4098
4099 uint32_t
4100 Session::next_return_id ()
4101 {
4102         /* this doesn't really loop forever. just think about it */
4103
4104         while (true) {
4105                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
4106                         if (!return_bitset[n]) {
4107                                 return_bitset[n] = true;
4108                                 return n;
4109
4110                         }
4111                 }
4112
4113                 /* none available, so resize and try again */
4114
4115                 return_bitset.resize (return_bitset.size() + 16, false);
4116         }
4117 }
4118
4119 void
4120 Session::mark_send_id (uint32_t id)
4121 {
4122         if (id >= send_bitset.size()) {
4123                 send_bitset.resize (id+16, false);
4124         }
4125         if (send_bitset[id]) {
4126                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4127         }
4128         send_bitset[id] = true;
4129 }
4130
4131 void
4132 Session::mark_aux_send_id (uint32_t id)
4133 {
4134         if (id >= aux_send_bitset.size()) {
4135                 aux_send_bitset.resize (id+16, false);
4136         }
4137         if (aux_send_bitset[id]) {
4138                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4139         }
4140         aux_send_bitset[id] = true;
4141 }
4142
4143 void
4144 Session::mark_return_id (uint32_t id)
4145 {
4146         if (id >= return_bitset.size()) {
4147                 return_bitset.resize (id+16, false);
4148         }
4149         if (return_bitset[id]) {
4150                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4151         }
4152         return_bitset[id] = true;
4153 }
4154
4155 void
4156 Session::mark_insert_id (uint32_t id)
4157 {
4158         if (id >= insert_bitset.size()) {
4159                 insert_bitset.resize (id+16, false);
4160         }
4161         if (insert_bitset[id]) {
4162                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4163         }
4164         insert_bitset[id] = true;
4165 }
4166
4167 void
4168 Session::unmark_send_id (uint32_t id)
4169 {
4170         if (id < send_bitset.size()) {
4171                 send_bitset[id] = false;
4172         }
4173 }
4174
4175 void
4176 Session::unmark_aux_send_id (uint32_t id)
4177 {
4178         if (id < aux_send_bitset.size()) {
4179                 aux_send_bitset[id] = false;
4180         }
4181 }
4182
4183 void
4184 Session::unmark_return_id (uint32_t id)
4185 {
4186         if (id < return_bitset.size()) {
4187                 return_bitset[id] = false;
4188         }
4189 }
4190
4191 void
4192 Session::unmark_insert_id (uint32_t id)
4193 {
4194         if (id < insert_bitset.size()) {
4195                 insert_bitset[id] = false;
4196         }
4197 }
4198
4199 void
4200 Session::reset_native_file_format ()
4201 {
4202         boost::shared_ptr<RouteList> rl = routes.reader ();
4203         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4204                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4205                 if (tr) {
4206                         /* don't save state as we do this, there's no point
4207                          */
4208
4209                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4210                         tr->reset_write_sources (false);
4211                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4212                 }
4213         }
4214 }
4215
4216 bool
4217 Session::route_name_unique (string n) const
4218 {
4219         boost::shared_ptr<RouteList> r = routes.reader ();
4220
4221         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4222                 if ((*i)->name() == n) {
4223                         return false;
4224                 }
4225         }
4226
4227         return true;
4228 }
4229
4230 bool
4231 Session::route_name_internal (string n) const
4232 {
4233         if (auditioner && auditioner->name() == n) {
4234                 return true;
4235         }
4236
4237         if (_click_io && _click_io->name() == n) {
4238                 return true;
4239         }
4240
4241         return false;
4242 }
4243
4244 int
4245 Session::freeze_all (InterThreadInfo& itt)
4246 {
4247         boost::shared_ptr<RouteList> r = routes.reader ();
4248
4249         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4250
4251                 boost::shared_ptr<Track> t;
4252
4253                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4254                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
4255                            of every track.
4256                         */
4257                         t->freeze_me (itt);
4258                 }
4259         }
4260
4261         return 0;
4262 }
4263
4264 boost::shared_ptr<Region>
4265 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
4266                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4267                           InterThreadInfo& itt,
4268                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4269                           bool for_export, bool for_freeze)
4270 {
4271         boost::shared_ptr<Region> result;
4272         boost::shared_ptr<Playlist> playlist;
4273         boost::shared_ptr<AudioFileSource> fsource;
4274         ChanCount diskstream_channels (track.n_channels());
4275         framepos_t position;
4276         framecnt_t this_chunk;
4277         framepos_t to_do;
4278         framepos_t latency_skip;
4279         BufferSet buffers;
4280         framepos_t len = end - start;
4281         bool need_block_size_reset = false;
4282         ChanCount const max_proc = track.max_processor_streams ();
4283         string legal_playlist_name;
4284         string possible_path;
4285
4286         if (end <= start) {
4287                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4288                                          end, start) << endmsg;
4289                 return result;
4290         }
4291
4292         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
4293                         include_endpoint, for_export, for_freeze);
4294
4295         if (diskstream_channels.n_audio() < 1) {
4296                 error << _("Cannot write a range with no audio.") << endmsg;
4297                 return result;
4298         }
4299
4300         // block all process callback handling
4301
4302         block_processing ();
4303
4304         {
4305                 // synchronize with AudioEngine::process_callback()
4306                 // make sure processing is not currently running
4307                 // and processing_blocked() is honored before
4308                 // acquiring thread buffers
4309                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4310         }
4311
4312         _bounce_processing_active = true;
4313
4314         /* call tree *MUST* hold route_lock */
4315
4316         if ((playlist = track.playlist()) == 0) {
4317                 goto out;
4318         }
4319
4320         legal_playlist_name = legalize_for_path (playlist->name());
4321
4322         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
4323
4324                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
4325                 string path = new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true);
4326
4327                 if (path.empty()) {
4328                         goto out;
4329                 }
4330
4331                 try {
4332                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4333                                 SourceFactory::createWritable (DataType::AUDIO, *this, path, false, frame_rate()));
4334                 }
4335
4336                 catch (failed_constructor& err) {
4337                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), path, track.name()) << endmsg;
4338                         goto out;
4339                 }
4340
4341                 srcs.push_back (fsource);
4342         }
4343
4344         /* tell redirects that care that we are about to use a much larger
4345          * blocksize. this will flush all plugins too, so that they are ready
4346          * to be used for this process.
4347          */
4348
4349         need_block_size_reset = true;
4350         track.set_block_size (bounce_chunk_size);
4351         _engine.main_thread()->get_buffers ();
4352
4353         position = start;
4354         to_do = len;
4355         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4356
4357         /* create a set of reasonably-sized buffers */
4358         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4359                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
4360         }
4361         buffers.set_count (max_proc);
4362
4363         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4364                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4365                 if (afs)
4366                         afs->prepare_for_peakfile_writes ();
4367         }
4368
4369         while (to_do && !itt.cancel) {
4370
4371                 this_chunk = min (to_do, bounce_chunk_size);
4372
4373                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
4374                         goto out;
4375                 }
4376
4377                 start += this_chunk;
4378                 to_do -= this_chunk;
4379                 itt.progress = (float) (1.0 - ((double) to_do / len));
4380
4381                 if (latency_skip >= bounce_chunk_size) {
4382                         latency_skip -= bounce_chunk_size;
4383                         continue;
4384                 }
4385
4386                 const framecnt_t current_chunk = this_chunk - latency_skip;
4387
4388                 uint32_t n = 0;
4389                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4390                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4391
4392                         if (afs) {
4393                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
4394                                         goto out;
4395                                 }
4396                         }
4397                 }
4398                 latency_skip = 0;
4399         }
4400
4401         /* post-roll, pick up delayed processor output */
4402         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4403
4404         while (latency_skip && !itt.cancel) {
4405                 this_chunk = min (latency_skip, bounce_chunk_size);
4406                 latency_skip -= this_chunk;
4407
4408                 buffers.silence (this_chunk, 0);
4409                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
4410
4411                 uint32_t n = 0;
4412                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4413                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4414
4415                         if (afs) {
4416                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4417                                         goto out;
4418                                 }
4419                         }
4420                 }
4421         }
4422
4423         if (!itt.cancel) {
4424
4425                 time_t now;
4426                 struct tm* xnow;
4427                 time (&now);
4428                 xnow = localtime (&now);
4429
4430                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4431                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4432
4433                         if (afs) {
4434                                 afs->update_header (position, *xnow, now);
4435                                 afs->flush_header ();
4436                         }
4437                 }
4438
4439                 /* construct a region to represent the bounced material */
4440
4441                 PropertyList plist;
4442
4443                 plist.add (Properties::start, 0);
4444                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4445                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4446
4447                 result = RegionFactory::create (srcs, plist);
4448
4449         }
4450
4451   out:
4452         if (!result) {
4453                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4454                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4455
4456                         if (afs) {
4457                                 afs->mark_for_remove ();
4458                         }
4459
4460                         (*src)->drop_references ();
4461                 }
4462
4463         } else {
4464                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4465                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4466
4467                         if (afs)
4468                                 afs->done_with_peakfile_writes ();
4469                 }
4470         }
4471
4472         _bounce_processing_active = false;
4473
4474         if (need_block_size_reset) {
4475                 _engine.main_thread()->drop_buffers ();
4476                 track.set_block_size (get_block_size());
4477         }
4478
4479         unblock_processing ();
4480
4481         return result;
4482 }
4483
4484 gain_t*
4485 Session::gain_automation_buffer() const
4486 {
4487         return ProcessThread::gain_automation_buffer ();
4488 }
4489
4490 gain_t*
4491 Session::send_gain_automation_buffer() const
4492 {
4493         return ProcessThread::send_gain_automation_buffer ();
4494 }
4495
4496 pan_t**
4497 Session::pan_automation_buffer() const
4498 {
4499         return ProcessThread::pan_automation_buffer ();
4500 }
4501
4502 BufferSet&
4503 Session::get_silent_buffers (ChanCount count)
4504 {
4505         return ProcessThread::get_silent_buffers (count);
4506 }
4507
4508 BufferSet&
4509 Session::get_scratch_buffers (ChanCount count, bool silence)
4510 {
4511         return ProcessThread::get_scratch_buffers (count, silence);
4512 }
4513
4514 BufferSet&
4515 Session::get_route_buffers (ChanCount count, bool silence)
4516 {
4517         return ProcessThread::get_route_buffers (count, silence);
4518 }
4519
4520
4521 BufferSet&
4522 Session::get_mix_buffers (ChanCount count)
4523 {
4524         return ProcessThread::get_mix_buffers (count);
4525 }
4526
4527 uint32_t
4528 Session::ntracks () const
4529 {
4530         uint32_t n = 0;
4531         boost::shared_ptr<RouteList> r = routes.reader ();
4532
4533         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4534                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4535                         ++n;
4536                 }
4537         }
4538
4539         return n;
4540 }
4541
4542 uint32_t
4543 Session::nbusses () const
4544 {
4545         uint32_t n = 0;
4546         boost::shared_ptr<RouteList> r = routes.reader ();
4547
4548         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4549                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4550                         ++n;
4551                 }
4552         }
4553
4554         return n;
4555 }
4556
4557 void
4558 Session::add_automation_list(AutomationList *al)
4559 {
4560         automation_lists[al->id()] = al;
4561 }
4562
4563 /** @return true if there is at least one record-enabled track, otherwise false */
4564 bool
4565 Session::have_rec_enabled_track () const
4566 {
4567         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4568 }
4569
4570 /** Update the state of our rec-enabled tracks flag */
4571 void
4572 Session::update_have_rec_enabled_track ()
4573 {
4574         boost::shared_ptr<RouteList> rl = routes.reader ();
4575         RouteList::iterator i = rl->begin();
4576         while (i != rl->end ()) {
4577
4578                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4579                 if (tr && tr->record_enabled ()) {
4580                         break;
4581                 }
4582
4583                 ++i;
4584         }
4585
4586         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4587
4588         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4589
4590         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4591                 RecordStateChanged (); /* EMIT SIGNAL */
4592         }
4593 }
4594
4595 void
4596 Session::listen_position_changed ()
4597 {
4598         boost::shared_ptr<RouteList> r = routes.reader ();
4599
4600         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4601                 (*i)->listen_position_changed ();
4602         }
4603 }
4604
4605 void
4606 Session::solo_control_mode_changed ()
4607 {
4608         /* cancel all solo or all listen when solo control mode changes */
4609
4610         if (soloing()) {
4611                 set_solo (get_routes(), false);
4612         } else if (listening()) {
4613                 set_listen (get_routes(), false);
4614         }
4615 }
4616
4617 /** Called when a property of one of our route groups changes */
4618 void
4619 Session::route_group_property_changed (RouteGroup* rg)
4620 {
4621         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4622 }
4623
4624 /** Called when a route is added to one of our route groups */
4625 void
4626 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4627 {
4628         RouteAddedToRouteGroup (rg, r);
4629 }
4630
4631 /** Called when a route is removed from one of our route groups */
4632 void
4633 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4634 {
4635         RouteRemovedFromRouteGroup (rg, r);
4636 }
4637
4638 boost::shared_ptr<RouteList>
4639 Session::get_tracks () const
4640 {
4641         boost::shared_ptr<RouteList> rl = routes.reader ();
4642         boost::shared_ptr<RouteList> tl (new RouteList);
4643
4644         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
4645                 if (boost::dynamic_pointer_cast<Track> (*r)) {
4646                         tl->push_back (*r);
4647                 }
4648         }
4649         return tl;
4650 }
4651
4652 boost::shared_ptr<RouteList>
4653 Session::get_routes_with_regions_at (framepos_t const p) const
4654 {
4655         boost::shared_ptr<RouteList> r = routes.reader ();
4656         boost::shared_ptr<RouteList> rl (new RouteList);
4657
4658         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4659                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4660                 if (!tr) {
4661                         continue;
4662                 }
4663
4664                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4665                 if (!pl) {
4666                         continue;
4667                 }
4668
4669                 if (pl->has_region_at (p)) {
4670                         rl->push_back (*i);
4671                 }
4672         }
4673
4674         return rl;
4675 }
4676
4677 void
4678 Session::goto_end ()
4679 {
4680         if (_session_range_location) {
4681                 request_locate (_session_range_location->end(), false);
4682         } else {
4683                 request_locate (0, false);
4684         }
4685 }
4686
4687 void
4688 Session::goto_start ()
4689 {
4690         if (_session_range_location) {
4691                 request_locate (_session_range_location->start(), false);
4692         } else {
4693                 request_locate (0, false);
4694         }
4695 }
4696
4697 framepos_t
4698 Session::current_start_frame () const
4699 {
4700         return _session_range_location ? _session_range_location->start() : 0;
4701 }
4702
4703 framepos_t
4704 Session::current_end_frame () const
4705 {
4706         return _session_range_location ? _session_range_location->end() : 0;
4707 }
4708
4709 void
4710 Session::add_session_range_location (framepos_t start, framepos_t end)
4711 {
4712         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4713         _locations->add (_session_range_location);
4714 }
4715
4716 void
4717 Session::step_edit_status_change (bool yn)
4718 {
4719         bool send = false;
4720
4721         bool val = false;
4722         if (yn) {
4723                 send = (_step_editors == 0);
4724                 val = true;
4725
4726                 _step_editors++;
4727         } else {
4728                 send = (_step_editors == 1);
4729                 val = false;
4730
4731                 if (_step_editors > 0) {
4732                         _step_editors--;
4733                 }
4734         }
4735
4736         if (send) {
4737                 StepEditStatusChange (val);
4738         }
4739 }
4740
4741
4742 void
4743 Session::start_time_changed (framepos_t old)
4744 {
4745         /* Update the auto loop range to match the session range
4746            (unless the auto loop range has been changed by the user)
4747         */
4748
4749         Location* s = _locations->session_range_location ();
4750         if (s == 0) {
4751                 return;
4752         }
4753
4754         Location* l = _locations->auto_loop_location ();
4755
4756         if (l && l->start() == old) {
4757                 l->set_start (s->start(), true);
4758         }
4759 }
4760
4761 void
4762 Session::end_time_changed (framepos_t old)
4763 {
4764         /* Update the auto loop range to match the session range
4765            (unless the auto loop range has been changed by the user)
4766         */
4767
4768         Location* s = _locations->session_range_location ();
4769         if (s == 0) {
4770                 return;
4771         }
4772
4773         Location* l = _locations->auto_loop_location ();
4774
4775         if (l && l->end() == old) {
4776                 l->set_end (s->end(), true);
4777         }
4778 }
4779
4780 std::vector<std::string>
4781 Session::source_search_path (DataType type) const
4782 {
4783         Searchpath sp;
4784
4785         if (session_dirs.size() == 1) {
4786                 switch (type) {
4787                 case DataType::AUDIO:
4788                         sp.push_back (_session_dir->sound_path());
4789                         break;
4790                 case DataType::MIDI:
4791                         sp.push_back (_session_dir->midi_path());
4792                         break;
4793                 }
4794         } else {
4795                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4796                         SessionDirectory sdir (i->path);
4797                         switch (type) {
4798                         case DataType::AUDIO:
4799                                 sp.push_back (sdir.sound_path());
4800                                 break;
4801                         case DataType::MIDI:
4802                                 sp.push_back (sdir.midi_path());
4803                                 break;
4804                         }
4805                 }
4806         }
4807
4808         if (type == DataType::AUDIO) {
4809                 const string sound_path_2X = _session_dir->sound_path_2X();
4810                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4811                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
4812                                 sp.push_back (sound_path_2X);
4813                         }
4814                 }
4815         }
4816
4817         // now check the explicit (possibly user-specified) search path
4818
4819         switch (type) {
4820         case DataType::AUDIO:
4821                 sp += Searchpath(config.get_audio_search_path ());
4822                 break;
4823         case DataType::MIDI:
4824                 sp += Searchpath(config.get_midi_search_path ());
4825                 break;
4826         }
4827
4828         return sp;
4829 }
4830
4831 void
4832 Session::ensure_search_path_includes (const string& path, DataType type)
4833 {
4834         Searchpath sp;
4835
4836         if (path == ".") {
4837                 return;
4838         }
4839
4840         switch (type) {
4841         case DataType::AUDIO:
4842                 sp += Searchpath(config.get_audio_search_path ());
4843                 break;
4844         case DataType::MIDI:
4845                 sp += Searchpath (config.get_midi_search_path ());
4846                 break;
4847         }
4848
4849         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
4850                 /* No need to add this new directory if it has the same inode as
4851                    an existing one; checking inode rather than name prevents duplicated
4852                    directories when we are using symlinks.
4853
4854                    On Windows, I think we could just do if (*i == path) here.
4855                 */
4856                 if (PBD::equivalent_paths (*i, path)) {
4857                         return;
4858                 }
4859         }
4860
4861         sp += path;
4862
4863         switch (type) {
4864         case DataType::AUDIO:
4865                 config.set_audio_search_path (sp.to_string());
4866                 break;
4867         case DataType::MIDI:
4868                 config.set_midi_search_path (sp.to_string());
4869                 break;
4870         }
4871 }
4872
4873 void
4874 Session::remove_dir_from_search_path (const string& dir, DataType type)
4875 {
4876         Searchpath sp;
4877
4878         switch (type) {
4879         case DataType::AUDIO:
4880                 sp = Searchpath(config.get_audio_search_path ());
4881                 break;
4882         case DataType::MIDI:
4883                 sp = Searchpath (config.get_midi_search_path ());
4884                 break;
4885         }
4886
4887         sp -= dir;
4888
4889         switch (type) {
4890         case DataType::AUDIO:
4891                 config.set_audio_search_path (sp.to_string());
4892                 break;
4893         case DataType::MIDI:
4894                 config.set_midi_search_path (sp.to_string());
4895                 break;
4896         }
4897
4898 }
4899
4900 boost::shared_ptr<Speakers>
4901 Session::get_speakers()
4902 {
4903         return _speakers;
4904 }
4905
4906 list<string>
4907 Session::unknown_processors () const
4908 {
4909         list<string> p;
4910
4911         boost::shared_ptr<RouteList> r = routes.reader ();
4912         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4913                 list<string> t = (*i)->unknown_processors ();
4914                 copy (t.begin(), t.end(), back_inserter (p));
4915         }
4916
4917         p.sort ();
4918         p.unique ();
4919
4920         return p;
4921 }
4922
4923 void
4924 Session::update_latency (bool playback)
4925 {
4926         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4927
4928         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4929                 return;
4930         }
4931
4932         boost::shared_ptr<RouteList> r = routes.reader ();
4933         framecnt_t max_latency = 0;
4934
4935         if (playback) {
4936                 /* reverse the list so that we work backwards from the last route to run to the first */
4937                 RouteList* rl = routes.reader().get();
4938                 r.reset (new RouteList (*rl));
4939                 reverse (r->begin(), r->end());
4940         }
4941
4942         /* compute actual latency values for the given direction and store them all in per-port
4943            structures. this will also publish the same values (to JACK) so that computation of latency
4944            for routes can consistently use public latency values.
4945         */
4946
4947         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4948                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4949         }
4950
4951         /* because we latency compensate playback, our published playback latencies should
4952            be the same for all output ports - all material played back by ardour has
4953            the same latency, whether its caused by plugins or by latency compensation. since
4954            these may differ from the values computed above, reset all playback port latencies
4955            to the same value.
4956         */
4957
4958         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4959
4960         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4961                 (*i)->set_public_port_latencies (max_latency, playback);
4962         }
4963
4964         if (playback) {
4965
4966                 post_playback_latency ();
4967
4968         } else {
4969
4970                 post_capture_latency ();
4971         }
4972
4973         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4974 }
4975
4976 void
4977 Session::post_playback_latency ()
4978 {
4979         set_worst_playback_latency ();
4980
4981         boost::shared_ptr<RouteList> r = routes.reader ();
4982
4983         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4984                 if (!(*i)->is_auditioner() && ((*i)->active())) {
4985                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4986                 }
4987         }
4988
4989         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4990                 (*i)->set_latency_compensation (_worst_track_latency);
4991         }
4992 }
4993
4994 void
4995 Session::post_capture_latency ()
4996 {
4997         set_worst_capture_latency ();
4998
4999         /* reflect any changes in capture latencies into capture offsets
5000          */
5001
5002         boost::shared_ptr<RouteList> rl = routes.reader();
5003         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5004                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5005                 if (tr) {
5006                         tr->set_capture_offset ();
5007                 }
5008         }
5009 }
5010
5011 void
5012 Session::initialize_latencies ()
5013 {
5014         {
5015                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5016                 update_latency (false);
5017                 update_latency (true);
5018         }
5019
5020         set_worst_io_latencies ();
5021 }
5022
5023 void
5024 Session::set_worst_io_latencies ()
5025 {
5026         set_worst_playback_latency ();
5027         set_worst_capture_latency ();
5028 }
5029
5030 void
5031 Session::set_worst_playback_latency ()
5032 {
5033         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5034                 return;
5035         }
5036
5037         _worst_output_latency = 0;
5038
5039         if (!_engine.connected()) {
5040                 return;
5041         }
5042
5043         boost::shared_ptr<RouteList> r = routes.reader ();
5044
5045         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5046                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5047         }
5048
5049         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5050 }
5051
5052 void
5053 Session::set_worst_capture_latency ()
5054 {
5055         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5056                 return;
5057         }
5058
5059         _worst_input_latency = 0;
5060
5061         if (!_engine.connected()) {
5062                 return;
5063         }
5064
5065         boost::shared_ptr<RouteList> r = routes.reader ();
5066
5067         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5068                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
5069         }
5070
5071         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
5072 }
5073
5074 void
5075 Session::update_latency_compensation (bool force_whole_graph)
5076 {
5077         bool some_track_latency_changed = false;
5078
5079         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5080                 return;
5081         }
5082
5083         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
5084
5085         _worst_track_latency = 0;
5086
5087         boost::shared_ptr<RouteList> r = routes.reader ();
5088
5089         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5090                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5091                         framecnt_t tl;
5092                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
5093                                 some_track_latency_changed = true;
5094                         }
5095                         _worst_track_latency = max (tl, _worst_track_latency);
5096                 }
5097         }
5098
5099         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
5100                                                      (some_track_latency_changed ? "yes" : "no")));
5101
5102         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
5103
5104         if (some_track_latency_changed || force_whole_graph)  {
5105                 _engine.update_latencies ();
5106         }
5107
5108
5109         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5110                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5111                 if (!tr) {
5112                         continue;
5113                 }
5114                 tr->set_capture_offset ();
5115         }
5116 }
5117
5118 char
5119 Session::session_name_is_legal (const string& path)
5120 {
5121         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
5122
5123         for (int i = 0; illegal_chars[i]; ++i) {
5124                 if (path.find (illegal_chars[i]) != string::npos) {
5125                         return illegal_chars[i];
5126                 }
5127         }
5128
5129         return 0;
5130 }
5131
5132 uint32_t
5133 Session::next_control_id () const
5134 {
5135         int subtract = 0;
5136
5137         /* the monitor bus remote ID is in a different
5138          * "namespace" than regular routes. its existence doesn't
5139          * affect normal (low) numbered routes.
5140          */
5141
5142         if (_monitor_out) {
5143                 subtract++;
5144         }
5145
5146         return nroutes() - subtract;
5147 }
5148
5149 void
5150 Session::notify_remote_id_change ()
5151 {
5152         if (deletion_in_progress()) {
5153                 return;
5154         }
5155
5156         switch (Config->get_remote_model()) {
5157         case MixerOrdered:
5158                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
5159                 break;
5160         default:
5161                 break;
5162         }
5163 }
5164
5165 void
5166 Session::sync_order_keys ()
5167 {
5168         if (deletion_in_progress()) {
5169                 return;
5170         }
5171
5172         /* tell everyone that something has happened to the sort keys
5173            and let them sync up with the change(s)
5174            this will give objects that manage the sort order keys the
5175            opportunity to keep them in sync if they wish to.
5176         */
5177
5178         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
5179
5180         reassign_track_numbers();
5181
5182         Route::SyncOrderKeys (); /* EMIT SIGNAL */
5183
5184         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
5185 }
5186
5187 bool
5188 Session::operation_in_progress (GQuark op) const
5189 {
5190         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
5191 }
5192
5193 boost::shared_ptr<Port>
5194 Session::ltc_input_port () const
5195 {
5196         return _ltc_input->nth (0);
5197 }
5198
5199 boost::shared_ptr<Port>
5200 Session::ltc_output_port () const
5201 {
5202         return _ltc_output->nth (0);
5203 }
5204
5205 void
5206 Session::reconnect_ltc_input ()
5207 {
5208         if (_ltc_input) {
5209
5210                 string src = Config->get_ltc_source_port();
5211
5212                 _ltc_input->disconnect (this);
5213
5214                 if (src != _("None") && !src.empty())  {
5215                         _ltc_input->nth (0)->connect (src);
5216                 }
5217         }
5218 }
5219
5220 void
5221 Session::reconnect_ltc_output ()
5222 {
5223         if (_ltc_output) {
5224
5225 #if 0
5226                 string src = Config->get_ltc_sink_port();
5227
5228                 _ltc_output->disconnect (this);
5229
5230                 if (src != _("None") && !src.empty())  {
5231                         _ltc_output->nth (0)->connect (src);
5232                 }
5233 #endif
5234         }
5235 }