libs/ardour/session.cc

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