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