libs/ardour/session.cc

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