libs/ardour/session.cc

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