libs/ardour/session.cc

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