libs/ardour/session.cc

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