libs/ardour/session.cc

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