libs/ardour/session.cc

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