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->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
1239         location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
1240         location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
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->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1281         location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1282         location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
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::locations_added (Location *)
1297 {
1298         _locations->apply (*this, &Session::sync_locations_to_skips);
1299         set_dirty ();
1300 }
1301
1302 void
1303 Session::locations_changed ()
1304 {
1305         _locations->apply (*this, &Session::handle_locations_changed);
1306 }
1307
1308 void
1309 Session::handle_locations_changed (Locations::LocationList& locations)
1310 {
1311         Locations::LocationList::iterator i;
1312         Location* location;
1313         bool set_loop = false;
1314         bool set_punch = false;
1315
1316         for (i = locations.begin(); i != locations.end(); ++i) {
1317
1318                 location =* i;
1319
1320                 if (location->is_auto_punch()) {
1321                         set_auto_punch_location (location);
1322                         set_punch = true;
1323                 }
1324                 if (location->is_auto_loop()) {
1325                         set_auto_loop_location (location);
1326                         set_loop = true;
1327                 }
1328
1329                 if (location->is_session_range()) {
1330                         _session_range_location = location;
1331                 }
1332         }
1333
1334         sync_locations_to_skips (locations);
1335
1336         if (!set_loop) {
1337                 set_auto_loop_location (0);
1338         }
1339         if (!set_punch) {
1340                 set_auto_punch_location (0);
1341         }
1342
1343         set_dirty();
1344 }
1345
1346 void
1347 Session::sync_locations_to_skips (Locations::LocationList& locations)
1348 {
1349         Locations::LocationList::iterator i;
1350         Location* location;
1351
1352         clear_events (SessionEvent::Skip);
1353
1354         for (i = locations.begin(); i != locations.end(); ++i) {
1355
1356                 location = *i;
1357
1358                 if (location->is_skip()) {
1359                         SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1360                         queue_event (ev);
1361                 }
1362         }
1363 }
1364
1365 void
1366 Session::enable_record ()
1367 {
1368         if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1369                 /* no recording at anything except normal speed */
1370                 return;
1371         }
1372
1373         while (1) {
1374                 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1375
1376                 if (rs == Recording) {
1377                         break;
1378                 }
1379
1380                 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1381
1382                         _last_record_location = _transport_frame;
1383                         _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1384
1385                         if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1386                                 set_track_monitor_input_status (true);
1387                         }
1388
1389                         RecordStateChanged ();
1390                         break;
1391                 }
1392         }
1393 }
1394
1395 void
1396 Session::disable_record (bool rt_context, bool force)
1397 {
1398         RecordState rs;
1399
1400         if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1401
1402                 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1403                         g_atomic_int_set (&_record_status, Disabled);
1404                         _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1405                 } else {
1406                         if (rs == Recording) {
1407                                 g_atomic_int_set (&_record_status, Enabled);
1408                         }
1409                 }
1410
1411                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1412                         set_track_monitor_input_status (false);
1413                 }
1414
1415                 RecordStateChanged (); /* emit signal */
1416
1417                 if (!rt_context) {
1418                         remove_pending_capture_state ();
1419                 }
1420         }
1421 }
1422
1423 void
1424 Session::step_back_from_record ()
1425 {
1426         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1427
1428                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1429                         set_track_monitor_input_status (false);
1430                 }
1431
1432                 RecordStateChanged (); /* emit signal */
1433         }
1434 }
1435
1436 void
1437 Session::maybe_enable_record ()
1438 {
1439         if (_step_editors > 0) {
1440                 return;
1441         }
1442
1443         g_atomic_int_set (&_record_status, Enabled);
1444
1445         /* This function is currently called from somewhere other than an RT thread.
1446            This save_state() call therefore doesn't impact anything.  Doing it here
1447            means that we save pending state of which sources the next record will use,
1448            which gives us some chance of recovering from a crash during the record.
1449         */
1450
1451         save_state ("", true);
1452
1453         if (_transport_speed) {
1454                 if (!config.get_punch_in()) {
1455                         enable_record ();
1456                 }
1457         } else {
1458                 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1459                 RecordStateChanged (); /* EMIT SIGNAL */
1460         }
1461
1462         set_dirty();
1463 }
1464
1465 framepos_t
1466 Session::audible_frame () const
1467 {
1468         framepos_t ret;
1469         framepos_t tf;
1470         framecnt_t offset;
1471
1472         offset = worst_playback_latency ();
1473
1474         if (synced_to_engine()) {
1475                 /* Note: this is basically just sync-to-JACK */
1476                 tf = _engine.transport_frame();
1477         } else {
1478                 tf = _transport_frame;
1479         }
1480
1481         ret = tf;
1482
1483         if (!non_realtime_work_pending()) {
1484
1485                 /* MOVING */
1486
1487                 /* Check to see if we have passed the first guaranteed
1488                    audible frame past our last start position. if not,
1489                    return that last start point because in terms
1490                    of audible frames, we have not moved yet.
1491
1492                    `Start position' in this context means the time we last
1493                    either started, located, or changed transport direction.
1494                 */
1495
1496                 if (_transport_speed > 0.0f) {
1497
1498                         if (!play_loop || !have_looped) {
1499                                 if (tf < _last_roll_or_reversal_location + offset) {
1500                                         return _last_roll_or_reversal_location;
1501                                 }
1502                         }
1503
1504
1505                         /* forwards */
1506                         ret -= offset;
1507
1508                 } else if (_transport_speed < 0.0f) {
1509
1510                         /* XXX wot? no backward looping? */
1511
1512                         if (tf > _last_roll_or_reversal_location - offset) {
1513                                 return _last_roll_or_reversal_location;
1514                         } else {
1515                                 /* backwards */
1516                                 ret += offset;
1517                         }
1518                 }
1519         }
1520
1521         return ret;
1522 }
1523
1524 void
1525 Session::set_frame_rate (framecnt_t frames_per_second)
1526 {
1527         /** \fn void Session::set_frame_size(framecnt_t)
1528                 the AudioEngine object that calls this guarantees
1529                 that it will not be called while we are also in
1530                 ::process(). Its fine to do things that block
1531                 here.
1532         */
1533
1534         _base_frame_rate = frames_per_second;
1535         _nominal_frame_rate = frames_per_second;
1536
1537         sync_time_vars();
1538
1539         clear_clicks ();
1540
1541         // XXX we need some equivalent to this, somehow
1542         // SndFileSource::setup_standard_crossfades (frames_per_second);
1543
1544         set_dirty();
1545
1546         /* XXX need to reset/reinstantiate all LADSPA plugins */
1547 }
1548
1549 void
1550 Session::set_block_size (pframes_t nframes)
1551 {
1552         /* the AudioEngine guarantees
1553            that it will not be called while we are also in
1554            ::process(). It is therefore fine to do things that block
1555            here.
1556         */
1557
1558         {
1559                 current_block_size = nframes;
1560
1561                 ensure_buffers ();
1562
1563                 boost::shared_ptr<RouteList> r = routes.reader ();
1564
1565                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1566                         (*i)->set_block_size (nframes);
1567                 }
1568
1569                 boost::shared_ptr<RouteList> rl = routes.reader ();
1570                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1571                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1572                         if (tr) {
1573                                 tr->set_block_size (nframes);
1574                         }
1575                 }
1576
1577                 set_worst_io_latencies ();
1578         }
1579 }
1580
1581
1582 static void
1583 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1584 {
1585         boost::shared_ptr<Route> r2;
1586
1587         if (r1->feeds (rbase) && rbase->feeds (r1)) {
1588                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1589                 return;
1590         }
1591
1592         /* make a copy of the existing list of routes that feed r1 */
1593
1594         Route::FedBy existing (r1->fed_by());
1595
1596         /* for each route that feeds r1, recurse, marking it as feeding
1597            rbase as well.
1598         */
1599
1600         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1601                 if (!(r2 = i->r.lock ())) {
1602                         /* (*i) went away, ignore it */
1603                         continue;
1604                 }
1605
1606                 /* r2 is a route that feeds r1 which somehow feeds base. mark
1607                    base as being fed by r2
1608                 */
1609
1610                 rbase->add_fed_by (r2, i->sends_only);
1611
1612                 if (r2 != rbase) {
1613
1614                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1615                            stop here.
1616                         */
1617
1618                         if (r1->feeds (r2) && r2->feeds (r1)) {
1619                                 continue;
1620                         }
1621
1622                         /* now recurse, so that we can mark base as being fed by
1623                            all routes that feed r2
1624                         */
1625
1626                         trace_terminal (r2, rbase);
1627                 }
1628
1629         }
1630 }
1631
1632 void
1633 Session::resort_routes ()
1634 {
1635         /* don't do anything here with signals emitted
1636            by Routes during initial setup or while we
1637            are being destroyed.
1638         */
1639
1640         if (_state_of_the_state & (InitialConnecting | Deletion)) {
1641                 return;
1642         }
1643
1644         {
1645                 RCUWriter<RouteList> writer (routes);
1646                 boost::shared_ptr<RouteList> r = writer.get_copy ();
1647                 resort_routes_using (r);
1648                 /* writer goes out of scope and forces update */
1649         }
1650
1651 #ifndef NDEBUG
1652         boost::shared_ptr<RouteList> rl = routes.reader ();
1653         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1654                 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1655
1656                 const Route::FedBy& fb ((*i)->fed_by());
1657
1658                 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1659                         boost::shared_ptr<Route> sf = f->r.lock();
1660                         if (sf) {
1661                                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1662                         }
1663                 }
1664         }
1665 #endif
1666
1667 }
1668
1669 /** This is called whenever we need to rebuild the graph of how we will process
1670  *  routes.
1671  *  @param r List of routes, in any order.
1672  */
1673
1674 void
1675 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1676 {
1677         /* We are going to build a directed graph of our routes;
1678            this is where the edges of that graph are put.
1679         */
1680
1681         GraphEdges edges;
1682
1683         /* Go through all routes doing two things:
1684          *
1685          * 1. Collect the edges of the route graph.  Each of these edges
1686          *    is a pair of routes, one of which directly feeds the other
1687          *    either by a JACK connection or by an internal send.
1688          *
1689          * 2. Begin the process of making routes aware of which other
1690          *    routes directly or indirectly feed them.  This information
1691          *    is used by the solo code.
1692          */
1693
1694         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1695
1696                 /* Clear out the route's list of direct or indirect feeds */
1697                 (*i)->clear_fed_by ();
1698
1699                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1700
1701                         bool via_sends_only;
1702
1703                         /* See if this *j feeds *i according to the current state of the JACK
1704                            connections and internal sends.
1705                         */
1706                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1707                                 /* add the edge to the graph (part #1) */
1708                                 edges.add (*j, *i, via_sends_only);
1709                                 /* tell the route (for part #2) */
1710                                 (*i)->add_fed_by (*j, via_sends_only);
1711                         }
1712                 }
1713         }
1714
1715         /* Attempt a topological sort of the route graph */
1716         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1717
1718         if (sorted_routes) {
1719                 /* We got a satisfactory topological sort, so there is no feedback;
1720                    use this new graph.
1721
1722                    Note: the process graph rechain does not require a
1723                    topologically-sorted list, but hey ho.
1724                 */
1725                 if (_process_graph) {
1726                         _process_graph->rechain (sorted_routes, edges);
1727                 }
1728
1729                 _current_route_graph = edges;
1730
1731                 /* Complete the building of the routes' lists of what directly
1732                    or indirectly feeds them.
1733                 */
1734                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1735                         trace_terminal (*i, *i);
1736                 }
1737
1738                 *r = *sorted_routes;
1739
1740 #ifndef NDEBUG
1741                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1742                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1743                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1744                                                                    (*i)->name(), (*i)->order_key ()));
1745                 }
1746 #endif
1747
1748                 SuccessfulGraphSort (); /* EMIT SIGNAL */
1749
1750         } else {
1751                 /* The topological sort failed, so we have a problem.  Tell everyone
1752                    and stick to the old graph; this will continue to be processed, so
1753                    until the feedback is fixed, what is played back will not quite
1754                    reflect what is actually connected.  Note also that we do not
1755                    do trace_terminal here, as it would fail due to an endless recursion,
1756                    so the solo code will think that everything is still connected
1757                    as it was before.
1758                 */
1759
1760                 FeedbackDetected (); /* EMIT SIGNAL */
1761         }
1762
1763 }
1764
1765 /** Find a route name starting with \a base, maybe followed by the
1766  *  lowest \a id.  \a id will always be added if \a definitely_add_number
1767  *  is true on entry; otherwise it will only be added if required
1768  *  to make the name unique.
1769  *
1770  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1771  *  The available route name with the lowest ID will be used, and \a id
1772  *  will be set to the ID.
1773  *
1774  *  \return false if a route name could not be found, and \a track_name
1775  *  and \a id do not reflect a free route name.
1776  */
1777 bool
1778 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1779 {
1780         if (!definitely_add_number && route_by_name (base) == 0) {
1781                 /* juse use the base */
1782                 snprintf (name, name_len, "%s", base.c_str());
1783                 return true;
1784         }
1785
1786         do {
1787                 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1788
1789                 if (route_by_name (name) == 0) {
1790                         return true;
1791                 }
1792
1793                 ++id;
1794
1795         } while (id < (UINT_MAX-1));
1796
1797         return false;
1798 }
1799
1800 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1801 void
1802 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1803 {
1804         in  = ChanCount::ZERO;
1805         out = ChanCount::ZERO;
1806
1807         boost::shared_ptr<RouteList> r = routes.reader ();
1808
1809         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1810                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1811                 if (tr && !tr->is_auditioner()) {
1812                         in  += tr->n_inputs();
1813                         out += tr->n_outputs();
1814                 }
1815         }
1816 }
1817
1818 /** Caller must not hold process lock
1819  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
1820  *  @param instrument plugin info for the instrument to insert pre-fader, if any
1821  */
1822 list<boost::shared_ptr<MidiTrack> >
1823 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1824                          TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1825 {
1826         char track_name[32];
1827         uint32_t track_id = 0;
1828         string port;
1829         RouteList new_routes;
1830         list<boost::shared_ptr<MidiTrack> > ret;
1831
1832         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1833
1834         while (how_many) {
1835                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1836                         error << "cannot find name for new midi track" << endmsg;
1837                         goto failed;
1838                 }
1839
1840                 boost::shared_ptr<MidiTrack> track;
1841
1842                 try {
1843                         track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1844
1845                         if (track->init ()) {
1846                                 goto failed;
1847                         }
1848
1849                         track->use_new_diskstream();
1850
1851 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1852                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1853 #endif
1854                         {
1855                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1856                                 if (track->input()->ensure_io (input, false, this)) {
1857                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1858                                         goto failed;
1859                                 }
1860
1861                                 if (track->output()->ensure_io (output, false, this)) {
1862                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1863                                         goto failed;
1864                                 }
1865                         }
1866
1867                         track->non_realtime_input_change();
1868
1869                         if (route_group) {
1870                                 route_group->add (track);
1871                         }
1872
1873                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1874
1875                         if (Config->get_remote_model() == UserOrdered) {
1876                                 track->set_remote_control_id (next_control_id());
1877                         }
1878
1879                         new_routes.push_back (track);
1880                         ret.push_back (track);
1881                 }
1882
1883                 catch (failed_constructor &err) {
1884                         error << _("Session: could not create new midi track.") << endmsg;
1885                         goto failed;
1886                 }
1887
1888                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1889
1890                         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;
1891                         goto failed;
1892                 }
1893
1894                 --how_many;
1895         }
1896
1897   failed:
1898         if (!new_routes.empty()) {
1899                 StateProtector sp (this);
1900                 add_routes (new_routes, true, true, true);
1901
1902                 if (instrument) {
1903                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1904                                 PluginPtr plugin = instrument->load (*this);
1905                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1906                                 (*r)->add_processor (p, PreFader);
1907
1908                         }
1909                 }
1910         }
1911
1912         return ret;
1913 }
1914
1915 void
1916 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1917 {
1918         boost::shared_ptr<Route> midi_track (wmt.lock());
1919
1920         if (!midi_track) {
1921                 return;
1922         }
1923
1924         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1925
1926                 if (change.after.n_audio() <= change.before.n_audio()) {
1927                         return;
1928                 }
1929
1930                 /* new audio ports: make sure the audio goes somewhere useful,
1931                    unless the user has no-auto-connect selected.
1932
1933                    The existing ChanCounts don't matter for this call as they are only
1934                    to do with matching input and output indices, and we are only changing
1935                    outputs here.
1936                 */
1937
1938                 ChanCount dummy;
1939
1940                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1941         }
1942 }
1943
1944 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1945  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1946  *  @param output_start As \a input_start, but for outputs.
1947  */
1948 void
1949 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1950                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1951 {
1952         if (!IO::connecting_legal) {
1953                 return;
1954         }
1955
1956         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1957
1958         if (with_lock) {
1959                 lm.acquire ();
1960         }
1961
1962         /* If both inputs and outputs are auto-connected to physical ports,
1963            use the max of input and output offsets to ensure auto-connected
1964            port numbers always match up (e.g. the first audio input and the
1965            first audio output of the route will have the same physical
1966            port number).  Otherwise just use the lowest input or output
1967            offset possible.
1968         */
1969
1970         DEBUG_TRACE (DEBUG::Graph,
1971                      string_compose("Auto-connect: existing in = %1 out = %2\n",
1972                                     existing_inputs, existing_outputs));
1973
1974         const bool in_out_physical =
1975                 (Config->get_input_auto_connect() & AutoConnectPhysical)
1976                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1977                 && connect_inputs;
1978
1979         const ChanCount in_offset = in_out_physical
1980                 ? ChanCount::max(existing_inputs, existing_outputs)
1981                 : existing_inputs;
1982
1983         const ChanCount out_offset = in_out_physical
1984                 ? ChanCount::max(existing_inputs, existing_outputs)
1985                 : existing_outputs;
1986
1987         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1988                 vector<string> physinputs;
1989                 vector<string> physoutputs;
1990
1991                 _engine.get_physical_outputs (*t, physoutputs);
1992                 _engine.get_physical_inputs (*t, physinputs);
1993
1994                 if (!physinputs.empty() && connect_inputs) {
1995                         uint32_t nphysical_in = physinputs.size();
1996
1997                         DEBUG_TRACE (DEBUG::Graph,
1998                                      string_compose("There are %1 physical inputs of type %2\n",
1999                                                     nphysical_in, *t));
2000
2001                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
2002                                 string port;
2003
2004                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
2005                                         DEBUG_TRACE (DEBUG::Graph,
2006                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
2007                                                                     in_offset.get(*t), i, nphysical_in,
2008                                                                     (in_offset.get(*t) + i) % nphysical_in));
2009                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
2010                                 }
2011
2012                                 DEBUG_TRACE (DEBUG::Graph,
2013                                              string_compose("Connect route %1 IN to %2\n",
2014                                                             route->name(), port));
2015
2016                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
2017                                         break;
2018                                 }
2019
2020                                 ChanCount one_added (*t, 1);
2021                                 existing_inputs += one_added;
2022                         }
2023                 }
2024
2025                 if (!physoutputs.empty()) {
2026                         uint32_t nphysical_out = physoutputs.size();
2027                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
2028                                 string port;
2029
2030                                 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
2031                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
2032                                 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
2033                                         /* master bus is audio only */
2034                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
2035                                                 port = _master_out->input()->ports().port(*t,
2036                                                                 i % _master_out->input()->n_ports().get(*t))->name();
2037                                         }
2038                                 }
2039
2040                                 DEBUG_TRACE (DEBUG::Graph,
2041                                              string_compose("Connect route %1 OUT to %2\n",
2042                                                             route->name(), port));
2043
2044                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2045                                         break;
2046                                 }
2047
2048                                 ChanCount one_added (*t, 1);
2049                                 existing_outputs += one_added;
2050                         }
2051                 }
2052         }
2053 }
2054
2055 void
2056 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2057 {
2058         /* TRX does stuff here, ardour does not (but probably should). This is called after an engine reset (in particular).
2059          */
2060 }
2061
2062
2063 /** Caller must not hold process lock
2064  *  @param name_template string to use for the start of the name, or "" to use "Audio".
2065  */
2066 list< boost::shared_ptr<AudioTrack> >
2067 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2068                           uint32_t how_many, string name_template)
2069 {
2070         char track_name[32];
2071         uint32_t track_id = 0;
2072         string port;
2073         RouteList new_routes;
2074         list<boost::shared_ptr<AudioTrack> > ret;
2075
2076         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
2077
2078         while (how_many) {
2079                 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2080                         error << "cannot find name for new audio track" << endmsg;
2081                         goto failed;
2082                 }
2083
2084                 boost::shared_ptr<AudioTrack> track;
2085
2086                 try {
2087                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2088
2089                         if (track->init ()) {
2090                                 goto failed;
2091                         }
2092
2093                         track->use_new_diskstream();
2094
2095 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2096                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2097 #endif
2098                         {
2099                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2100
2101                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2102                                         error << string_compose (
2103                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2104                                                 input_channels, output_channels)
2105                                               << endmsg;
2106                                         goto failed;
2107                                 }
2108
2109                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2110                                         error << string_compose (
2111                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
2112                                                 input_channels, output_channels)
2113                                               << endmsg;
2114                                         goto failed;
2115                                 }
2116                         }
2117
2118                         if (route_group) {
2119                                 route_group->add (track);
2120                         }
2121
2122                         track->non_realtime_input_change();
2123
2124                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2125                         if (Config->get_remote_model() == UserOrdered) {
2126                                 track->set_remote_control_id (next_control_id());
2127                         }
2128
2129                         new_routes.push_back (track);
2130                         ret.push_back (track);
2131                 }
2132
2133                 catch (failed_constructor &err) {
2134                         error << _("Session: could not create new audio track.") << endmsg;
2135                         goto failed;
2136                 }
2137
2138                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2139
2140                         error << pfe.what() << endmsg;
2141                         goto failed;
2142                 }
2143
2144                 --how_many;
2145         }
2146
2147   failed:
2148         if (!new_routes.empty()) {
2149                 StateProtector sp (this);
2150                 add_routes (new_routes, true, true, true);
2151         }
2152
2153         return ret;
2154 }
2155
2156 /** Caller must not hold process lock.
2157  *  @param name_template string to use for the start of the name, or "" to use "Bus".
2158  */
2159 RouteList
2160 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2161 {
2162         char bus_name[32];
2163         uint32_t bus_id = 0;
2164         string port;
2165         RouteList ret;
2166
2167         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2168
2169         while (how_many) {
2170                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2171                         error << "cannot find name for new audio bus" << endmsg;
2172                         goto failure;
2173                 }
2174
2175                 try {
2176                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2177
2178                         if (bus->init ()) {
2179                                 goto failure;
2180                         }
2181
2182 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2183                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2184 #endif
2185                         {
2186                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2187
2188                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2189                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2190                                                                  input_channels, output_channels)
2191                                               << endmsg;
2192                                         goto failure;
2193                                 }
2194
2195
2196                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2197                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2198                                                                  input_channels, output_channels)
2199                                               << endmsg;
2200                                         goto failure;
2201                                 }
2202                         }
2203
2204                         if (route_group) {
2205                                 route_group->add (bus);
2206                         }
2207                         if (Config->get_remote_model() == UserOrdered) {
2208                                 bus->set_remote_control_id (next_control_id());
2209                         }
2210
2211                         bus->add_internal_return ();
2212
2213                         ret.push_back (bus);
2214
2215                         ARDOUR::GUIIdle ();
2216                 }
2217
2218
2219                 catch (failed_constructor &err) {
2220                         error << _("Session: could not create new audio route.") << endmsg;
2221                         goto failure;
2222                 }
2223
2224                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2225                         error << pfe.what() << endmsg;
2226                         goto failure;
2227                 }
2228
2229
2230                 --how_many;
2231         }
2232
2233   failure:
2234         if (!ret.empty()) {
2235                 StateProtector sp (this);
2236                 add_routes (ret, false, true, true); // autoconnect outputs only
2237         }
2238
2239         return ret;
2240
2241 }
2242
2243 RouteList
2244 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2245 {
2246         RouteList ret;
2247         uint32_t control_id;
2248         XMLTree tree;
2249         uint32_t number = 0;
2250         const uint32_t being_added = how_many;
2251
2252         if (!tree.read (template_path.c_str())) {
2253                 return ret;
2254         }
2255
2256         XMLNode* node = tree.root();
2257
2258         IO::disable_connecting ();
2259
2260         control_id = next_control_id ();
2261
2262         while (how_many) {
2263
2264                 XMLNode node_copy (*node);
2265
2266                 /* Remove IDs of everything so that new ones are used */
2267                 node_copy.remove_property_recursively (X_("id"));
2268
2269                 try {
2270                         char name[32];
2271
2272                         if (!name_base.empty()) {
2273
2274                                 /* if we're adding more than one routes, force
2275                                  * all the names of the new routes to be
2276                                  * numbered, via the final parameter.
2277                                  */
2278
2279                                 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2280                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2281                                         /*NOTREACHDE*/
2282                                 }
2283
2284                         } else {
2285
2286                                 string const route_name  = node_copy.property(X_("name"))->value ();
2287
2288                                 /* generate a new name by adding a number to the end of the template name */
2289                                 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2290                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2291                                         /*NOTREACHED*/
2292                                 }
2293                         }
2294
2295                         /* set this name in the XML description that we are about to use */
2296                         Route::set_name_in_state (node_copy, name);
2297
2298                         /* trim bitslots from listen sends so that new ones are used */
2299                         XMLNodeList children = node_copy.children ();
2300                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2301                                 if ((*i)->name() == X_("Processor")) {
2302                                         XMLProperty* role = (*i)->property (X_("role"));
2303                                         if (role && role->value() == X_("Listen")) {
2304                                                 (*i)->remove_property (X_("bitslot"));
2305                                         }
2306                                 }
2307                         }
2308
2309                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2310
2311                         if (route == 0) {
2312                                 error << _("Session: cannot create track/bus from template description") << endmsg;
2313                                 goto out;
2314                         }
2315
2316                         if (boost::dynamic_pointer_cast<Track>(route)) {
2317                                 /* force input/output change signals so that the new diskstream
2318                                    picks up the configuration of the route. During session
2319                                    loading this normally happens in a different way.
2320                                 */
2321
2322                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2323
2324                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2325                                 change.after = route->input()->n_ports();
2326                                 route->input()->changed (change, this);
2327                                 change.after = route->output()->n_ports();
2328                                 route->output()->changed (change, this);
2329                         }
2330
2331                         route->set_remote_control_id (control_id);
2332                         ++control_id;
2333
2334                         ret.push_back (route);
2335                 }
2336
2337                 catch (failed_constructor &err) {
2338                         error << _("Session: could not create new route from template") << endmsg;
2339                         goto out;
2340                 }
2341
2342                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2343                         error << pfe.what() << endmsg;
2344                         goto out;
2345                 }
2346
2347                 --how_many;
2348         }
2349
2350   out:
2351         if (!ret.empty()) {
2352                 StateProtector sp (this);
2353                 add_routes (ret, true, true, true);
2354                 IO::enable_connecting ();
2355         }
2356
2357         return ret;
2358 }
2359
2360 void
2361 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2362 {
2363         try {
2364                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2365                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2366
2367         } catch (...) {
2368                 error << _("Adding new tracks/busses failed") << endmsg;
2369         }
2370
2371         graph_reordered ();
2372
2373         update_latency (true);
2374         update_latency (false);
2375
2376         set_dirty();
2377
2378         if (save) {
2379                 save_state (_current_snapshot_name);
2380         }
2381
2382         reassign_track_numbers();
2383
2384         RouteAdded (new_routes); /* EMIT SIGNAL */
2385 }
2386
2387 void
2388 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2389 {
2390         ChanCount existing_inputs;
2391         ChanCount existing_outputs;
2392         uint32_t order = next_control_id();
2393
2394         if (_order_hint != 0) {
2395                 order = _order_hint;
2396                 _order_hint = 0;
2397         }
2398
2399         count_existing_track_channels (existing_inputs, existing_outputs);
2400
2401         {
2402                 RCUWriter<RouteList> writer (routes);
2403                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2404                 r->insert (r->end(), new_routes.begin(), new_routes.end());
2405
2406                 /* if there is no control out and we're not in the middle of loading,
2407                    resort the graph here. if there is a control out, we will resort
2408                    toward the end of this method. if we are in the middle of loading,
2409                    we will resort when done.
2410                 */
2411
2412                 if (!_monitor_out && IO::connecting_legal) {
2413                         resort_routes_using (r);
2414                 }
2415         }
2416
2417         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2418
2419                 boost::weak_ptr<Route> wpr (*x);
2420                 boost::shared_ptr<Route> r (*x);
2421
2422                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2423                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2424                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2425                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2426                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2427                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2428
2429                 if (r->is_master()) {
2430                         _master_out = r;
2431                 }
2432
2433                 if (r->is_monitor()) {
2434                         _monitor_out = r;
2435                 }
2436
2437                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2438                 if (tr) {
2439                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2440                         track_playlist_changed (boost::weak_ptr<Track> (tr));
2441                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2442
2443                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2444                         if (mt) {
2445                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2446                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2447                         }
2448                 }
2449
2450
2451                 if (input_auto_connect || output_auto_connect) {
2452                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2453                 }
2454
2455                 /* order keys are a GUI responsibility but we need to set up
2456                    reasonable defaults because they also affect the remote control
2457                    ID in most situations.
2458                 */
2459
2460                 if (!r->has_order_key ()) {
2461                         if (r->is_auditioner()) {
2462                                 /* use an arbitrarily high value */
2463                                 r->set_order_key (UINT_MAX);
2464                         } else {
2465                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2466                                 r->set_order_key (order);
2467                                 order++;
2468                         }
2469                 }
2470
2471                 ARDOUR::GUIIdle ();
2472         }
2473
2474         if (_monitor_out && IO::connecting_legal) {
2475                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2476
2477                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2478                         if ((*x)->is_monitor()) {
2479                                 /* relax */
2480                         } else if ((*x)->is_master()) {
2481                                         /* relax */
2482                         } else {
2483                                 (*x)->enable_monitor_send ();
2484                         }
2485                 }
2486         }
2487 }
2488
2489 void
2490 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2491 {
2492         boost::shared_ptr<RouteList> r = routes.reader ();
2493         boost::shared_ptr<Send> s;
2494
2495         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2496                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2497                         s->amp()->gain_control()->set_value (0.0);
2498                 }
2499         }
2500 }
2501
2502 void
2503 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2504 {
2505         boost::shared_ptr<RouteList> r = routes.reader ();
2506         boost::shared_ptr<Send> s;
2507
2508         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2509                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2510                         s->amp()->gain_control()->set_value (1.0);
2511                 }
2512         }
2513 }
2514
2515 void
2516 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2517 {
2518         boost::shared_ptr<RouteList> r = routes.reader ();
2519         boost::shared_ptr<Send> s;
2520
2521         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2522                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2523                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2524                 }
2525         }
2526 }
2527
2528 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2529 void
2530 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2531 {
2532         boost::shared_ptr<RouteList> r = routes.reader ();
2533         boost::shared_ptr<RouteList> t (new RouteList);
2534
2535         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2536                 /* no MIDI sends because there are no MIDI busses yet */
2537                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2538                         t->push_back (*i);
2539                 }
2540         }
2541
2542         add_internal_sends (dest, p, t);
2543 }
2544
2545 void
2546 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2547 {
2548         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2549                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2550         }
2551 }
2552
2553 void
2554 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2555 {
2556         add_internal_send (dest, sender->before_processor_for_index (index), sender);
2557 }
2558
2559 void
2560 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2561 {
2562         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2563                 return;
2564         }
2565
2566         if (!dest->internal_return()) {
2567                 dest->add_internal_return ();
2568         }
2569
2570         sender->add_aux_send (dest, before);
2571
2572         graph_reordered ();
2573 }
2574
2575 void
2576 Session::remove_route (boost::shared_ptr<Route> route)
2577 {
2578         if (route == _master_out) {
2579                 return;
2580         }
2581
2582         route->set_solo (false, this);
2583
2584         {
2585                 RCUWriter<RouteList> writer (routes);
2586                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2587
2588                 rs->remove (route);
2589
2590                 /* deleting the master out seems like a dumb
2591                    idea, but its more of a UI policy issue
2592                    than our concern.
2593                 */
2594
2595                 if (route == _master_out) {
2596                         _master_out = boost::shared_ptr<Route> ();
2597                 }
2598
2599                 if (route == _monitor_out) {
2600                         _monitor_out.reset ();
2601                 }
2602
2603                 /* writer goes out of scope, forces route list update */
2604         }
2605
2606         update_route_solo_state ();
2607
2608         // We need to disconnect the route's inputs and outputs
2609
2610         route->input()->disconnect (0);
2611         route->output()->disconnect (0);
2612
2613         /* if the route had internal sends sending to it, remove them */
2614         if (route->internal_return()) {
2615
2616                 boost::shared_ptr<RouteList> r = routes.reader ();
2617                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2618                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2619                         if (s) {
2620                                 (*i)->remove_processor (s);
2621                         }
2622                 }
2623         }
2624
2625         /* if the monitoring section had a pointer to this route, remove it */
2626         if (_monitor_out && !route->is_master() && !route->is_monitor()) {
2627                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2628                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
2629                 route->remove_aux_or_listen (_monitor_out);
2630         }
2631
2632         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2633         if (mt && mt->step_editing()) {
2634                 if (_step_editors > 0) {
2635                         _step_editors--;
2636                 }
2637         }
2638
2639         update_latency_compensation ();
2640         set_dirty();
2641
2642         /* Re-sort routes to remove the graph's current references to the one that is
2643          * going away, then flush old references out of the graph.
2644          */
2645
2646         resort_routes ();
2647         if (_process_graph) {
2648                 _process_graph->clear_other_chain ();
2649         }
2650
2651         /* get rid of it from the dead wood collection in the route list manager */
2652
2653         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2654
2655         routes.flush ();
2656
2657         /* try to cause everyone to drop their references */
2658
2659         route->drop_references ();
2660
2661         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2662
2663         /* save the new state of the world */
2664
2665         if (save_state (_current_snapshot_name)) {
2666                 save_history (_current_snapshot_name);
2667         }
2668         reassign_track_numbers();
2669 }
2670
2671 void
2672 Session::route_mute_changed (void* /*src*/)
2673 {
2674         set_dirty ();
2675 }
2676
2677 void
2678 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2679 {
2680         boost::shared_ptr<Route> route = wpr.lock();
2681         if (!route) {
2682                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2683                 return;
2684         }
2685
2686         if (route->listening_via_monitor ()) {
2687
2688                 if (Config->get_exclusive_solo()) {
2689                         /* new listen: disable all other listen */
2690                         boost::shared_ptr<RouteList> r = routes.reader ();
2691                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2692                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
2693                                         continue;
2694                                 }
2695                                 (*i)->set_listen (false, this);
2696                         }
2697                 }
2698
2699                 _listen_cnt++;
2700
2701         } else if (_listen_cnt > 0) {
2702
2703                 _listen_cnt--;
2704         }
2705
2706         update_route_solo_state ();
2707 }
2708 void
2709 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2710 {
2711         boost::shared_ptr<Route> route = wpr.lock ();
2712
2713         if (!route) {
2714                 /* should not happen */
2715                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2716                 return;
2717         }
2718
2719         bool send_changed = false;
2720
2721         if (route->solo_isolated()) {
2722                 if (_solo_isolated_cnt == 0) {
2723                         send_changed = true;
2724                 }
2725                 _solo_isolated_cnt++;
2726         } else if (_solo_isolated_cnt > 0) {
2727                 _solo_isolated_cnt--;
2728                 if (_solo_isolated_cnt == 0) {
2729                         send_changed = true;
2730                 }
2731         }
2732
2733         if (send_changed) {
2734                 IsolatedChanged (); /* EMIT SIGNAL */
2735         }
2736 }
2737
2738 void
2739 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2740 {
2741         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2742
2743         if (!self_solo_change) {
2744                 // session doesn't care about changes to soloed-by-others
2745                 return;
2746         }
2747
2748         if (solo_update_disabled) {
2749                 // We know already
2750                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2751                 return;
2752         }
2753
2754         boost::shared_ptr<Route> route = wpr.lock ();
2755         assert (route);
2756
2757         boost::shared_ptr<RouteList> r = routes.reader ();
2758         int32_t delta;
2759
2760         if (route->self_soloed()) {
2761                 delta = 1;
2762         } else {
2763                 delta = -1;
2764         }
2765
2766         RouteGroup* rg = route->route_group ();
2767         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2768
2769         if (delta == 1 && Config->get_exclusive_solo()) {
2770
2771                 /* new solo: disable all other solos, but not the group if its solo-enabled */
2772
2773                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2774                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2775                             (leave_group_alone && ((*i)->route_group() == rg))) {
2776                                 continue;
2777                         }
2778                         (*i)->set_solo (false, this);
2779                 }
2780         }
2781
2782         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2783
2784         solo_update_disabled = true;
2785
2786         RouteList uninvolved;
2787
2788         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2789
2790         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2791                 bool via_sends_only;
2792                 bool in_signal_flow;
2793
2794                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2795                     (leave_group_alone && ((*i)->route_group() == rg))) {
2796                         continue;
2797                 }
2798
2799                 in_signal_flow = false;
2800
2801                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2802
2803                 if ((*i)->feeds (route, &via_sends_only)) {
2804                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2805                         if (!via_sends_only) {
2806                                 if (!route->soloed_by_others_upstream()) {
2807                                         (*i)->mod_solo_by_others_downstream (delta);
2808                                 }
2809                         } else {
2810                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2811                         }
2812                         in_signal_flow = true;
2813                 } else {
2814                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2815                 }
2816
2817                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2818
2819                 if (route->feeds (*i, &via_sends_only)) {
2820                         /* propagate solo upstream only if routing other than
2821                            sends is involved, but do consider the other route
2822                            (*i) to be part of the signal flow even if only
2823                            sends are involved.
2824                         */
2825                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2826                                                                   route->name(),
2827                                                                   (*i)->name(),
2828                                                                   via_sends_only,
2829                                                                   route->soloed_by_others_downstream(),
2830                                                                   route->soloed_by_others_upstream()));
2831                         if (!via_sends_only) {
2832                                 if (!route->soloed_by_others_downstream()) {
2833                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2834                                         (*i)->mod_solo_by_others_upstream (delta);
2835                                 } else {
2836                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2837                                 }
2838                         } else {
2839                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2840                         }
2841                         in_signal_flow = true;
2842                 } else {
2843                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2844                 }
2845
2846                 if (!in_signal_flow) {
2847                         uninvolved.push_back (*i);
2848                 }
2849         }
2850
2851         solo_update_disabled = false;
2852         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2853
2854         update_route_solo_state (r);
2855
2856         /* now notify that the mute state of the routes not involved in the signal
2857            pathway of the just-solo-changed route may have altered.
2858         */
2859
2860         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2861                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2862                 (*i)->mute_changed (this);
2863         }
2864
2865         SoloChanged (); /* EMIT SIGNAL */
2866         set_dirty();
2867 }
2868
2869 void
2870 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2871 {
2872         /* now figure out if anything that matters is soloed (or is "listening")*/
2873
2874         bool something_soloed = false;
2875         uint32_t listeners = 0;
2876         uint32_t isolated = 0;
2877
2878         if (!r) {
2879                 r = routes.reader();
2880         }
2881
2882         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2883                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
2884                         something_soloed = true;
2885                 }
2886
2887                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
2888                         if (Config->get_solo_control_is_listen_control()) {
2889                                 listeners++;
2890                         } else {
2891                                 (*i)->set_listen (false, this);
2892                         }
2893                 }
2894
2895                 if ((*i)->solo_isolated()) {
2896                         isolated++;
2897                 }
2898         }
2899
2900         if (something_soloed != _non_soloed_outs_muted) {
2901                 _non_soloed_outs_muted = something_soloed;
2902                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2903         }
2904
2905         _listen_cnt = listeners;
2906
2907         if (isolated != _solo_isolated_cnt) {
2908                 _solo_isolated_cnt = isolated;
2909                 IsolatedChanged (); /* EMIT SIGNAL */
2910         }
2911
2912         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2913                                                   something_soloed, listeners, isolated));
2914 }
2915
2916 boost::shared_ptr<RouteList>
2917 Session::get_routes_with_internal_returns() const
2918 {
2919         boost::shared_ptr<RouteList> r = routes.reader ();
2920         boost::shared_ptr<RouteList> rl (new RouteList);
2921
2922         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2923                 if ((*i)->internal_return ()) {
2924                         rl->push_back (*i);
2925                 }
2926         }
2927         return rl;
2928 }
2929
2930 bool
2931 Session::io_name_is_legal (const std::string& name)
2932 {
2933         boost::shared_ptr<RouteList> r = routes.reader ();
2934
2935         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2936                 if ((*i)->name() == name) {
2937                         return false;
2938                 }
2939
2940                 if ((*i)->has_io_processor_named (name)) {
2941                         return false;
2942                 }
2943         }
2944
2945         return true;
2946 }
2947
2948 void
2949 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2950 {
2951         RouteList rl2;
2952         vector<string> connections;
2953
2954         /* if we are passed only a single route and we're not told to turn
2955          * others off, then just do the simple thing.
2956          */
2957
2958         if (flip_others == false && rl->size() == 1) {
2959                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2960                 if (mt) {
2961                         mt->set_input_active (onoff);
2962                         return;
2963                 }
2964         }
2965
2966         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2967
2968                 PortSet& ps ((*rt)->input()->ports());
2969
2970                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2971                         p->get_connections (connections);
2972                 }
2973
2974                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2975                         routes_using_input_from (*s, rl2);
2976                 }
2977
2978                 /* scan all relevant routes to see if others are on or off */
2979
2980                 bool others_are_already_on = false;
2981
2982                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2983
2984                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2985
2986                         if (!mt) {
2987                                 continue;
2988                         }
2989
2990                         if ((*r) != (*rt)) {
2991                                 if (mt->input_active()) {
2992                                         others_are_already_on = true;
2993                                 }
2994                         } else {
2995                                 /* this one needs changing */
2996                                 mt->set_input_active (onoff);
2997                         }
2998                 }
2999
3000                 if (flip_others) {
3001
3002                         /* globally reverse other routes */
3003
3004                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3005                                 if ((*r) != (*rt)) {
3006                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3007                                         if (mt) {
3008                                                 mt->set_input_active (!others_are_already_on);
3009                                         }
3010                                 }
3011                         }
3012                 }
3013         }
3014 }
3015
3016 void
3017 Session::routes_using_input_from (const string& str, RouteList& rl)
3018 {
3019         boost::shared_ptr<RouteList> r = routes.reader();
3020
3021         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3022                 if ((*i)->input()->connected_to (str)) {
3023                         rl.push_back (*i);
3024                 }
3025         }
3026 }
3027
3028 boost::shared_ptr<Route>
3029 Session::route_by_name (string name)
3030 {
3031         boost::shared_ptr<RouteList> r = routes.reader ();
3032
3033         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3034                 if ((*i)->name() == name) {
3035                         return *i;
3036                 }
3037         }
3038
3039         return boost::shared_ptr<Route> ((Route*) 0);
3040 }
3041
3042 boost::shared_ptr<Route>
3043 Session::route_by_id (PBD::ID id)
3044 {
3045         boost::shared_ptr<RouteList> r = routes.reader ();
3046
3047         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3048                 if ((*i)->id() == id) {
3049                         return *i;
3050                 }
3051         }
3052
3053         return boost::shared_ptr<Route> ((Route*) 0);
3054 }
3055
3056 boost::shared_ptr<Track>
3057 Session::track_by_diskstream_id (PBD::ID id)
3058 {
3059         boost::shared_ptr<RouteList> r = routes.reader ();
3060
3061         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3062                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3063                 if (t && t->using_diskstream_id (id)) {
3064                         return t;
3065                 }
3066         }
3067
3068         return boost::shared_ptr<Track> ();
3069 }
3070
3071 boost::shared_ptr<Route>
3072 Session::route_by_remote_id (uint32_t id)
3073 {
3074         boost::shared_ptr<RouteList> r = routes.reader ();
3075
3076         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3077                 if ((*i)->remote_control_id() == id) {
3078                         return *i;
3079                 }
3080         }
3081
3082         return boost::shared_ptr<Route> ((Route*) 0);
3083 }
3084
3085
3086 void
3087 Session::reassign_track_numbers ()
3088 {
3089         int64_t tn = 0;
3090         int64_t bn = 0;
3091         RouteList r (*(routes.reader ()));
3092         SignalOrderRouteSorter sorter;
3093         r.sort (sorter);
3094
3095         StateProtector sp (this);
3096
3097         for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3098                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3099                         (*i)->set_track_number(++tn);
3100                 }
3101                 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
3102                         (*i)->set_track_number(--bn);
3103                 }
3104         }
3105         const uint32_t decimals = ceilf (log10f (tn + 1));
3106         const bool decimals_changed = _track_number_decimals != decimals;
3107         _track_number_decimals = decimals;
3108
3109         if (decimals_changed && config.get_track_name_number ()) {
3110                 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3111                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3112                         if (t) {
3113                                 t->resync_track_name();
3114                         }
3115                 }
3116                 // trigger GUI re-layout
3117                 config.ParameterChanged("track-name-number");
3118         }
3119 }
3120
3121 void
3122 Session::playlist_region_added (boost::weak_ptr<Region> w)
3123 {
3124         boost::shared_ptr<Region> r = w.lock ();
3125         if (!r) {
3126                 return;
3127         }
3128
3129         /* These are the operations that are currently in progress... */
3130         list<GQuark> curr = _current_trans_quarks;
3131         curr.sort ();
3132
3133         /* ...and these are the operations during which we want to update
3134            the session range location markers.
3135         */
3136         list<GQuark> ops;
3137         ops.push_back (Operations::capture);
3138         ops.push_back (Operations::paste);
3139         ops.push_back (Operations::duplicate_region);
3140         ops.push_back (Operations::insert_file);
3141         ops.push_back (Operations::insert_region);
3142         ops.push_back (Operations::drag_region_brush);
3143         ops.push_back (Operations::region_drag);
3144         ops.push_back (Operations::selection_grab);
3145         ops.push_back (Operations::region_fill);
3146         ops.push_back (Operations::fill_selection);
3147         ops.push_back (Operations::create_region);
3148         ops.push_back (Operations::region_copy);
3149         ops.push_back (Operations::fixed_time_region_copy);
3150         ops.sort ();
3151
3152         /* See if any of the current operations match the ones that we want */
3153         list<GQuark> in;
3154         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3155
3156         /* If so, update the session range markers */
3157         if (!in.empty ()) {
3158                 maybe_update_session_range (r->position (), r->last_frame ());
3159         }
3160 }
3161
3162 /** Update the session range markers if a is before the current start or
3163  *  b is after the current end.
3164  */
3165 void
3166 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3167 {
3168         if (_state_of_the_state & Loading) {
3169                 return;
3170         }
3171
3172         if (_session_range_location == 0) {
3173
3174                 add_session_range_location (a, b);
3175
3176         } else {
3177
3178                 if (a < _session_range_location->start()) {
3179                         _session_range_location->set_start (a);
3180                 }
3181
3182                 if (b > _session_range_location->end()) {
3183                         _session_range_location->set_end (b);
3184                 }
3185         }
3186 }
3187
3188 void
3189 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3190 {
3191         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3192                 maybe_update_session_range (i->to, i->to + i->length);
3193         }
3194 }
3195
3196 void
3197 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3198 {
3199         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3200                 maybe_update_session_range (i->from, i->to);
3201         }
3202 }
3203
3204 /* Region management */
3205
3206 boost::shared_ptr<Region>
3207 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3208 {
3209         const RegionFactory::RegionMap& regions (RegionFactory::regions());
3210         RegionFactory::RegionMap::const_iterator i;
3211         boost::shared_ptr<Region> region;
3212
3213         Glib::Threads::Mutex::Lock lm (region_lock);
3214
3215         for (i = regions.begin(); i != regions.end(); ++i) {
3216
3217                 region = i->second;
3218
3219                 if (region->whole_file()) {
3220
3221                         if (child->source_equivalent (region)) {
3222                                 return region;
3223                         }
3224                 }
3225         }
3226
3227         return boost::shared_ptr<Region> ();
3228 }
3229
3230 int
3231 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3232 {
3233         set<boost::shared_ptr<Region> > relevant_regions;
3234
3235         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3236                 RegionFactory::get_regions_using_source (*s, relevant_regions);
3237         }
3238
3239         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3240                 set<boost::shared_ptr<Region> >::iterator tmp;
3241
3242                 tmp = r;
3243                 ++tmp;
3244
3245                 playlists->destroy_region (*r);
3246                 RegionFactory::map_remove (*r);
3247
3248                 (*r)->drop_sources ();
3249                 (*r)->drop_references ();
3250
3251                 relevant_regions.erase (r);
3252
3253                 r = tmp;
3254         }
3255
3256         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3257
3258                 {
3259                         Glib::Threads::Mutex::Lock ls (source_lock);
3260                         /* remove from the main source list */
3261                         sources.erase ((*s)->id());
3262                 }
3263
3264                 (*s)->mark_for_remove ();
3265                 (*s)->drop_references ();
3266
3267                 s = srcs.erase (s);
3268         }
3269
3270         return 0;
3271 }
3272
3273 int
3274 Session::remove_last_capture ()
3275 {
3276         list<boost::shared_ptr<Source> > srcs;
3277
3278         boost::shared_ptr<RouteList> rl = routes.reader ();
3279         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3280                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3281                 if (!tr) {
3282                         continue;
3283                 }
3284
3285                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3286
3287                 if (!l.empty()) {
3288                         srcs.insert (srcs.end(), l.begin(), l.end());
3289                         l.clear ();
3290                 }
3291         }
3292
3293         destroy_sources (srcs);
3294
3295         save_state (_current_snapshot_name);
3296
3297         return 0;
3298 }
3299
3300 /* Source Management */
3301
3302 void
3303 Session::add_source (boost::shared_ptr<Source> source)
3304 {
3305         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3306         pair<SourceMap::iterator,bool> result;
3307
3308         entry.first = source->id();
3309         entry.second = source;
3310
3311         {
3312                 Glib::Threads::Mutex::Lock lm (source_lock);
3313                 result = sources.insert (entry);
3314         }
3315
3316         if (result.second) {
3317
3318                 /* yay, new source */
3319
3320                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3321
3322                 if (fs) {
3323                         if (!fs->within_session()) {
3324                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3325                         }
3326                 }
3327
3328                 set_dirty();
3329
3330                 boost::shared_ptr<AudioFileSource> afs;
3331
3332                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3333                         if (Config->get_auto_analyse_audio()) {
3334                                 Analyser::queue_source_for_analysis (source, false);
3335                         }
3336                 }
3337
3338                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3339         }
3340 }
3341
3342 void
3343 Session::remove_source (boost::weak_ptr<Source> src)
3344 {
3345         if (_state_of_the_state & Deletion) {
3346                 return;
3347         }
3348
3349         SourceMap::iterator i;
3350         boost::shared_ptr<Source> source = src.lock();
3351
3352         if (!source) {
3353                 return;
3354         }
3355
3356         {
3357                 Glib::Threads::Mutex::Lock lm (source_lock);
3358
3359                 if ((i = sources.find (source->id())) != sources.end()) {
3360                         sources.erase (i);
3361                 }
3362         }
3363
3364         if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
3365
3366                 /* save state so we don't end up with a session file
3367                    referring to non-existent sources.
3368                 */
3369
3370                 save_state (_current_snapshot_name);
3371         }
3372 }
3373
3374 boost::shared_ptr<Source>
3375 Session::source_by_id (const PBD::ID& id)
3376 {
3377         Glib::Threads::Mutex::Lock lm (source_lock);
3378         SourceMap::iterator i;
3379         boost::shared_ptr<Source> source;
3380
3381         if ((i = sources.find (id)) != sources.end()) {
3382                 source = i->second;
3383         }
3384
3385         return source;
3386 }
3387
3388 boost::shared_ptr<AudioFileSource>
3389 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
3390 {
3391         /* Restricted to audio files because only audio sources have channel
3392            as a property.
3393         */
3394
3395         Glib::Threads::Mutex::Lock lm (source_lock);
3396
3397         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
3398                 boost::shared_ptr<AudioFileSource> afs
3399                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3400
3401                 if (afs && afs->path() == path && chn == afs->channel()) {
3402                         return afs;
3403                 }
3404         }
3405
3406         return boost::shared_ptr<AudioFileSource>();
3407 }
3408
3409 boost::shared_ptr<MidiSource>
3410 Session::midi_source_by_path (const std::string& path) const
3411 {
3412         /* Restricted to MIDI files because audio sources require a channel
3413            for unique identification, in addition to a path.
3414         */
3415
3416         Glib::Threads::Mutex::Lock lm (source_lock);
3417
3418         for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
3419                 boost::shared_ptr<MidiSource> ms
3420                         = boost::dynamic_pointer_cast<MidiSource>(s->second);
3421                 boost::shared_ptr<FileSource> fs
3422                         = boost::dynamic_pointer_cast<FileSource>(s->second);
3423
3424                 if (ms && fs && fs->path() == path) {
3425                         return ms;
3426                 }
3427         }
3428
3429         return boost::shared_ptr<MidiSource>();
3430 }
3431
3432 uint32_t
3433 Session::count_sources_by_origin (const string& path)
3434 {
3435         uint32_t cnt = 0;
3436         Glib::Threads::Mutex::Lock lm (source_lock);
3437
3438         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3439                 boost::shared_ptr<FileSource> fs
3440                         = boost::dynamic_pointer_cast<FileSource>(i->second);
3441
3442                 if (fs && fs->origin() == path) {
3443                         ++cnt;
3444                 }
3445         }
3446
3447         return cnt;
3448 }
3449
3450 string
3451 Session::peak_path (string base) const
3452 {
3453         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3454 }
3455
3456 string
3457 Session::new_audio_source_path_for_embedded (const std::string& path)
3458 {
3459         /* embedded source:
3460          *
3461          * we know that the filename is already unique because it exists
3462          * out in the filesystem.
3463          *
3464          * However, when we bring it into the session, we could get a
3465          * collision.
3466          *
3467          * Eg. two embedded files:
3468          *
3469          *          /foo/bar/baz.wav
3470          *          /frob/nic/baz.wav
3471          *
3472          * When merged into session, these collide.
3473          *
3474          * There will not be a conflict with in-memory sources
3475          * because when the source was created we already picked
3476          * a unique name for it.
3477          *
3478          * This collision is not likely to be common, but we have to guard
3479          * against it.  So, if there is a collision, take the md5 hash of the
3480          * the path, and use that as the filename instead.
3481          */
3482
3483         SessionDirectory sdir (get_best_session_directory_for_new_audio());
3484         string base = Glib::path_get_basename (path);
3485         string newpath = Glib::build_filename (sdir.sound_path(), base);
3486
3487         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
3488
3489                 MD5 md5;
3490
3491                 md5.digestString (path.c_str());
3492                 md5.writeToString ();
3493                 base = md5.digestChars;
3494
3495                 string ext = get_suffix (path);
3496
3497                 if (!ext.empty()) {
3498                         base += '.';
3499                         base += ext;
3500                 }
3501
3502                 newpath = Glib::build_filename (sdir.sound_path(), base);
3503
3504                 /* if this collides, we're screwed */
3505
3506                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
3507                         error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
3508                         return string();
3509                 }
3510
3511         }
3512
3513         return newpath;
3514 }
3515
3516 bool
3517 Session::audio_source_name_is_unique (const string& name, uint32_t chan)
3518 {
3519         std::vector<string> sdirs = source_search_path (DataType::AUDIO);
3520         vector<space_and_path>::iterator i;
3521         uint32_t existing = 0;
3522
3523         for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
3524
3525                 /* note that we search *without* the extension so that
3526                    we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3527                    in the event that this new name is required for
3528                    a file format change.
3529                 */
3530
3531                 const string spath = *i;
3532
3533                 if (matching_unsuffixed_filename_exists_in (spath, name)) {
3534                         existing++;
3535                         break;
3536                 }
3537
3538                 /* it is possible that we have the path already
3539                  * assigned to a source that has not yet been written
3540                  * (ie. the write source for a diskstream). we have to
3541                  * check this in order to make sure that our candidate
3542                  * path isn't used again, because that can lead to
3543                  * two Sources point to the same file with different
3544                  * notions of their removability.
3545                  */
3546
3547
3548                 string possible_path = Glib::build_filename (spath, name);
3549
3550                 if (audio_source_by_path_and_channel (possible_path, chan)) {
3551                         existing++;
3552                         break;
3553                 }
3554         }
3555
3556         return (existing == 0);
3557 }
3558
3559 string
3560 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)
3561 {
3562         ostringstream sstr;
3563         const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3564
3565         if (destructive) {
3566                 sstr << 'T';
3567                 sstr << setfill ('0') << setw (4) << cnt;
3568                 sstr << legalized_base;
3569         } else {
3570                 sstr << legalized_base;
3571
3572                 if (take_required || related_exists) {
3573                         sstr << '-';
3574                         sstr << cnt;
3575                 }
3576         }
3577
3578         if (nchan == 2) {
3579                 if (chan == 0) {
3580                         sstr << "%L";
3581                 } else {
3582                         sstr << "%R";
3583                 }
3584         } else if (nchan > 2) {
3585                 if (nchan < 26) {
3586                         sstr << '%';
3587                         sstr << 'a' + chan;
3588                 } else {
3589                         /* XXX what? more than 26 channels! */
3590                         sstr << '%';
3591                         sstr << chan+1;
3592                 }
3593         }
3594
3595         sstr << ext;
3596
3597         return sstr.str();
3598 }
3599
3600 /** Return a unique name based on \a base for a new internal audio source */
3601 string
3602 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
3603 {
3604         uint32_t cnt;
3605         string possible_name;
3606         const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
3607         string legalized;
3608         bool some_related_source_name_exists = false;
3609
3610         legalized = legalize_for_path (base);
3611
3612         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3613
3614         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3615
3616                 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
3617
3618                 if (audio_source_name_is_unique (possible_name, chan)) {
3619                         break;
3620                 }
3621
3622                 some_related_source_name_exists = true;
3623
3624                 if (cnt > limit) {
3625                         error << string_compose(
3626                                         _("There are already %1 recordings for %2, which I consider too many."),
3627                                         limit, base) << endmsg;
3628                         destroy ();
3629                         throw failed_constructor();
3630                 }
3631         }
3632
3633         /* We've established that the new name does not exist in any session
3634          * directory, so now find out which one we should use for this new
3635          * audio source.
3636          */
3637
3638         SessionDirectory sdir (get_best_session_directory_for_new_audio());
3639
3640         std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
3641
3642         return s;
3643 }
3644
3645 /** Return a unique name based on \a owner_name for a new internal MIDI source */
3646 string
3647 Session::new_midi_source_path (const string& base)
3648 {
3649         uint32_t cnt;
3650         char buf[PATH_MAX+1];
3651         const uint32_t limit = 10000;
3652         string legalized;
3653         string possible_path;
3654         string possible_name;
3655
3656         buf[0] = '\0';
3657         legalized = legalize_for_path (base);
3658
3659         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3660         std::vector<string> sdirs = source_search_path(DataType::MIDI);
3661
3662         /* - the main session folder is the first in the vector.
3663          * - after checking all locations for file-name uniqueness,
3664          *   we keep the one from the last iteration as new file name
3665          * - midi files are small and should just be kept in the main session-folder
3666          *
3667          * -> reverse the array, check main session folder last and use that as location
3668          *    for MIDI files.
3669          */
3670         std::reverse(sdirs.begin(), sdirs.end());
3671
3672         for (cnt = 1; cnt <= limit; ++cnt) {
3673
3674                 vector<space_and_path>::iterator i;
3675                 uint32_t existing = 0;
3676
3677                 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
3678
3679                         snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
3680                         possible_name = buf;
3681
3682                         possible_path = Glib::build_filename (*i, possible_name);
3683
3684                         if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
3685                                 existing++;
3686                         }
3687
3688                         if (midi_source_by_path (possible_path)) {
3689                                 existing++;
3690                         }
3691                 }
3692
3693                 if (existing == 0) {
3694                         break;
3695                 }
3696
3697                 if (cnt > limit) {
3698                         error << string_compose(
3699                                         _("There are already %1 recordings for %2, which I consider too many."),
3700                                         limit, base) << endmsg;
3701                         destroy ();
3702                         return 0;
3703                 }
3704         }
3705
3706         /* No need to "find best location" for software/app-based RAID, because
3707            MIDI is so small that we always put it in the same place.
3708         */
3709
3710         return possible_path;
3711 }
3712
3713
3714 /** Create a new within-session audio source */
3715 boost::shared_ptr<AudioFileSource>
3716 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
3717 {
3718         const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
3719
3720         if (!path.empty()) {
3721                 return boost::dynamic_pointer_cast<AudioFileSource> (
3722                         SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3723         } else {
3724                 throw failed_constructor ();
3725         }
3726 }
3727
3728 /** Create a new within-session MIDI source */
3729 boost::shared_ptr<MidiSource>
3730 Session::create_midi_source_for_session (string const & basic_name)
3731 {
3732         const string path = new_midi_source_path (basic_name);
3733
3734         if (!path.empty()) {
3735                 return boost::dynamic_pointer_cast<SMFSource> (
3736                         SourceFactory::createWritable (
3737                                 DataType::MIDI, *this, path, false, frame_rate()));
3738         } else {
3739                 throw failed_constructor ();
3740         }
3741 }
3742
3743 /** Create a new within-session MIDI source */
3744 boost::shared_ptr<MidiSource>
3745 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
3746 {
3747         /* the caller passes in the track the source will be used in,
3748            so that we can keep the numbering sane.
3749
3750            Rationale: a track with the name "Foo" that has had N
3751            captures carried out so far will ALREADY have a write source
3752            named "Foo-N+1.mid" waiting to be used for the next capture.
3753
3754            If we call new_midi_source_name() we will get "Foo-N+2". But
3755            there is no region corresponding to "Foo-N+1", so when
3756            "Foo-N+2" appears in the track, the gap presents the user
3757            with odd behaviour - why did it skip past Foo-N+1?
3758
3759            We could explain this to the user in some odd way, but
3760            instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
3761            use "Foo-N+1" here.
3762
3763            If that attempted rename fails, we get "Foo-N+2.mid" anyway.
3764         */
3765
3766         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
3767         assert (mt);
3768         std::string name = track->steal_write_source_name ();
3769
3770         if (name.empty()) {
3771                 return boost::shared_ptr<MidiSource>();
3772         }
3773
3774         /* MIDI files are small, just put them in the first location of the
3775            session source search path.
3776         */
3777
3778         const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
3779
3780         return boost::dynamic_pointer_cast<SMFSource> (
3781                 SourceFactory::createWritable (
3782                         DataType::MIDI, *this, path, false, frame_rate()));
3783 }
3784
3785
3786 void
3787 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3788 {
3789         if (playlist->hidden()) {
3790                 return;
3791         }
3792
3793         playlists->add (playlist);
3794
3795         if (unused) {
3796                 playlist->release();
3797         }
3798
3799         set_dirty();
3800 }
3801
3802 void
3803 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3804 {
3805         if (_state_of_the_state & Deletion) {
3806                 return;
3807         }
3808
3809         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3810
3811         if (!playlist) {
3812                 return;
3813         }
3814
3815         playlists->remove (playlist);
3816
3817         set_dirty();
3818 }
3819
3820 void
3821 Session::set_audition (boost::shared_ptr<Region> r)
3822 {
3823         pending_audition_region = r;
3824         add_post_transport_work (PostTransportAudition);
3825         _butler->schedule_transport_work ();
3826 }
3827
3828 void
3829 Session::audition_playlist ()
3830 {
3831         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3832         ev->region.reset ();
3833         queue_event (ev);
3834 }
3835
3836 void
3837 Session::non_realtime_set_audition ()
3838 {
3839         assert (pending_audition_region);
3840         auditioner->audition_region (pending_audition_region);
3841         pending_audition_region.reset ();
3842         AuditionActive (true); /* EMIT SIGNAL */
3843 }
3844
3845 void
3846 Session::audition_region (boost::shared_ptr<Region> r)
3847 {
3848         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3849         ev->region = r;
3850         queue_event (ev);
3851 }
3852
3853 void
3854 Session::cancel_audition ()
3855 {
3856         if (!auditioner) {
3857                 return;
3858         }
3859         if (auditioner->auditioning()) {
3860                 auditioner->cancel_audition ();
3861                 AuditionActive (false); /* EMIT SIGNAL */
3862         }
3863 }
3864
3865 bool
3866 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3867 {
3868         if (a->is_monitor()) {
3869                 return true;
3870         }
3871         if (b->is_monitor()) {
3872                 return false;
3873         }
3874         return a->order_key () < b->order_key ();
3875 }
3876
3877 bool
3878 Session::is_auditioning () const
3879 {
3880         /* can be called before we have an auditioner object */
3881         if (auditioner) {
3882                 return auditioner->auditioning();
3883         } else {
3884                 return false;
3885         }
3886 }
3887
3888 void
3889 Session::graph_reordered ()
3890 {
3891         /* don't do this stuff if we are setting up connections
3892            from a set_state() call or creating new tracks. Ditto for deletion.
3893         */
3894
3895         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3896                 return;
3897         }
3898
3899         /* every track/bus asked for this to be handled but it was deferred because
3900            we were connecting. do it now.
3901         */
3902
3903         request_input_change_handling ();
3904
3905         resort_routes ();
3906
3907         /* force all diskstreams to update their capture offset values to
3908            reflect any changes in latencies within the graph.
3909         */
3910
3911         boost::shared_ptr<RouteList> rl = routes.reader ();
3912         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3913                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3914                 if (tr) {
3915                         tr->set_capture_offset ();
3916                 }
3917         }
3918 }
3919
3920 /** @return Number of frames that there is disk space available to write,
3921  *  if known.
3922  */
3923 boost::optional<framecnt_t>
3924 Session::available_capture_duration ()
3925 {
3926         Glib::Threads::Mutex::Lock lm (space_lock);
3927
3928         if (_total_free_4k_blocks_uncertain) {
3929                 return boost::optional<framecnt_t> ();
3930         }
3931
3932         float sample_bytes_on_disk = 4.0; // keep gcc happy
3933
3934         switch (config.get_native_file_data_format()) {
3935         case FormatFloat:
3936                 sample_bytes_on_disk = 4.0;
3937                 break;
3938
3939         case FormatInt24:
3940                 sample_bytes_on_disk = 3.0;
3941                 break;
3942
3943         case FormatInt16:
3944                 sample_bytes_on_disk = 2.0;
3945                 break;
3946
3947         default:
3948                 /* impossible, but keep some gcc versions happy */
3949                 fatal << string_compose (_("programming error: %1"),
3950                                          X_("illegal native file data format"))
3951                       << endmsg;
3952                 /*NOTREACHED*/
3953         }
3954
3955         double scale = 4096.0 / sample_bytes_on_disk;
3956
3957         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3958                 return max_framecnt;
3959         }
3960
3961         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3962 }
3963
3964 void
3965 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3966 {
3967         {
3968                 RCUWriter<BundleList> writer (_bundles);
3969                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3970                 b->push_back (bundle);
3971         }
3972
3973         BundleAdded (bundle); /* EMIT SIGNAL */
3974
3975         set_dirty();
3976 }
3977
3978 void
3979 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3980 {
3981         bool removed = false;
3982
3983         {
3984                 RCUWriter<BundleList> writer (_bundles);
3985                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3986                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3987
3988                 if (i != b->end()) {
3989                         b->erase (i);
3990                         removed = true;
3991                 }
3992         }
3993
3994         if (removed) {
3995                  BundleRemoved (bundle); /* EMIT SIGNAL */
3996         }
3997
3998         set_dirty();
3999 }
4000
4001 boost::shared_ptr<Bundle>
4002 Session::bundle_by_name (string name) const
4003 {
4004         boost::shared_ptr<BundleList> b = _bundles.reader ();
4005
4006         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
4007                 if ((*i)->name() == name) {
4008                         return* i;
4009                 }
4010         }
4011
4012         return boost::shared_ptr<Bundle> ();
4013 }
4014
4015 void
4016 Session::tempo_map_changed (const PropertyChange&)
4017 {
4018         clear_clicks ();
4019
4020         playlists->update_after_tempo_map_change ();
4021
4022         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4023
4024         set_dirty ();
4025 }
4026
4027 void
4028 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
4029 {
4030         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
4031                 (*i)->recompute_frames_from_bbt ();
4032         }
4033 }
4034
4035 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4036  * the given count with the current block size.
4037  */
4038 void
4039 Session::ensure_buffers (ChanCount howmany)
4040 {
4041         BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4042 }
4043
4044 void
4045 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4046 {
4047         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4048                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4049         }
4050 }
4051
4052 uint32_t
4053 Session::next_insert_id ()
4054 {
4055         /* this doesn't really loop forever. just think about it */
4056
4057         while (true) {
4058                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4059                         if (!insert_bitset[n]) {
4060                                 insert_bitset[n] = true;
4061                                 return n;
4062
4063                         }
4064                 }
4065
4066                 /* none available, so resize and try again */
4067
4068                 insert_bitset.resize (insert_bitset.size() + 16, false);
4069         }
4070 }
4071
4072 uint32_t
4073 Session::next_send_id ()
4074 {
4075         /* this doesn't really loop forever. just think about it */
4076
4077         while (true) {
4078                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4079                         if (!send_bitset[n]) {
4080                                 send_bitset[n] = true;
4081                                 return n;
4082
4083                         }
4084                 }
4085
4086                 /* none available, so resize and try again */
4087
4088                 send_bitset.resize (send_bitset.size() + 16, false);
4089         }
4090 }
4091
4092 uint32_t
4093 Session::next_aux_send_id ()
4094 {
4095         /* this doesn't really loop forever. just think about it */
4096
4097         while (true) {
4098                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4099                         if (!aux_send_bitset[n]) {
4100                                 aux_send_bitset[n] = true;
4101                                 return n;
4102
4103                         }
4104                 }
4105
4106                 /* none available, so resize and try again */
4107
4108                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4109         }
4110 }
4111
4112 uint32_t
4113 Session::next_return_id ()
4114 {
4115         /* this doesn't really loop forever. just think about it */
4116
4117         while (true) {
4118                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
4119                         if (!return_bitset[n]) {
4120                                 return_bitset[n] = true;
4121                                 return n;
4122
4123                         }
4124                 }
4125
4126                 /* none available, so resize and try again */
4127
4128                 return_bitset.resize (return_bitset.size() + 16, false);
4129         }
4130 }
4131
4132 void
4133 Session::mark_send_id (uint32_t id)
4134 {
4135         if (id >= send_bitset.size()) {
4136                 send_bitset.resize (id+16, false);
4137         }
4138         if (send_bitset[id]) {
4139                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4140         }
4141         send_bitset[id] = true;
4142 }
4143
4144 void
4145 Session::mark_aux_send_id (uint32_t id)
4146 {
4147         if (id >= aux_send_bitset.size()) {
4148                 aux_send_bitset.resize (id+16, false);
4149         }
4150         if (aux_send_bitset[id]) {
4151                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4152         }
4153         aux_send_bitset[id] = true;
4154 }
4155
4156 void
4157 Session::mark_return_id (uint32_t id)
4158 {
4159         if (id >= return_bitset.size()) {
4160                 return_bitset.resize (id+16, false);
4161         }
4162         if (return_bitset[id]) {
4163                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4164         }
4165         return_bitset[id] = true;
4166 }
4167
4168 void
4169 Session::mark_insert_id (uint32_t id)
4170 {
4171         if (id >= insert_bitset.size()) {
4172                 insert_bitset.resize (id+16, false);
4173         }
4174         if (insert_bitset[id]) {
4175                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4176         }
4177         insert_bitset[id] = true;
4178 }
4179
4180 void
4181 Session::unmark_send_id (uint32_t id)
4182 {
4183         if (id < send_bitset.size()) {
4184                 send_bitset[id] = false;
4185         }
4186 }
4187
4188 void
4189 Session::unmark_aux_send_id (uint32_t id)
4190 {
4191         if (id < aux_send_bitset.size()) {
4192                 aux_send_bitset[id] = false;
4193         }
4194 }
4195
4196 void
4197 Session::unmark_return_id (uint32_t id)
4198 {
4199         if (id < return_bitset.size()) {
4200                 return_bitset[id] = false;
4201         }
4202 }
4203
4204 void
4205 Session::unmark_insert_id (uint32_t id)
4206 {
4207         if (id < insert_bitset.size()) {
4208                 insert_bitset[id] = false;
4209         }
4210 }
4211
4212 void
4213 Session::reset_native_file_format ()
4214 {
4215         boost::shared_ptr<RouteList> rl = routes.reader ();
4216         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4217                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4218                 if (tr) {
4219                         /* don't save state as we do this, there's no point
4220                          */
4221
4222                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4223                         tr->reset_write_sources (false);
4224                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4225                 }
4226         }
4227 }
4228
4229 bool
4230 Session::route_name_unique (string n) const
4231 {
4232         boost::shared_ptr<RouteList> r = routes.reader ();
4233
4234         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4235                 if ((*i)->name() == n) {
4236                         return false;
4237                 }
4238         }
4239
4240         return true;
4241 }
4242
4243 bool
4244 Session::route_name_internal (string n) const
4245 {
4246         if (auditioner && auditioner->name() == n) {
4247                 return true;
4248         }
4249
4250         if (_click_io && _click_io->name() == n) {
4251                 return true;
4252         }
4253
4254         return false;
4255 }
4256
4257 int
4258 Session::freeze_all (InterThreadInfo& itt)
4259 {
4260         boost::shared_ptr<RouteList> r = routes.reader ();
4261
4262         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4263
4264                 boost::shared_ptr<Track> t;
4265
4266                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4267                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
4268                            of every track.
4269                         */
4270                         t->freeze_me (itt);
4271                 }
4272         }
4273
4274         return 0;
4275 }
4276
4277 boost::shared_ptr<Region>
4278 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
4279                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4280                           InterThreadInfo& itt,
4281                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4282                           bool for_export, bool for_freeze)
4283 {
4284         boost::shared_ptr<Region> result;
4285         boost::shared_ptr<Playlist> playlist;
4286         boost::shared_ptr<AudioFileSource> fsource;
4287         ChanCount diskstream_channels (track.n_channels());
4288         framepos_t position;
4289         framecnt_t this_chunk;
4290         framepos_t to_do;
4291         framepos_t latency_skip;
4292         BufferSet buffers;
4293         framepos_t len = end - start;
4294         bool need_block_size_reset = false;
4295         ChanCount const max_proc = track.max_processor_streams ();
4296         string legal_playlist_name;
4297         string possible_path;
4298
4299         if (end <= start) {
4300                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4301                                          end, start) << endmsg;
4302                 return result;
4303         }
4304
4305         diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
4306                         include_endpoint, for_export, for_freeze);
4307
4308         if (diskstream_channels.n_audio() < 1) {
4309                 error << _("Cannot write a range with no audio.") << endmsg;
4310                 return result;
4311         }
4312
4313         // block all process callback handling
4314
4315         block_processing ();
4316
4317         {
4318                 // synchronize with AudioEngine::process_callback()
4319                 // make sure processing is not currently running
4320                 // and processing_blocked() is honored before
4321                 // acquiring thread buffers
4322                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4323         }
4324
4325         _bounce_processing_active = true;
4326
4327         /* call tree *MUST* hold route_lock */
4328
4329         if ((playlist = track.playlist()) == 0) {
4330                 goto out;
4331         }
4332
4333         legal_playlist_name = legalize_for_path (playlist->name());
4334
4335         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
4336
4337                 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
4338                 string path = new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true);
4339
4340                 if (path.empty()) {
4341                         goto out;
4342                 }
4343
4344                 try {
4345                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4346                                 SourceFactory::createWritable (DataType::AUDIO, *this, path, false, frame_rate()));
4347                 }
4348
4349                 catch (failed_constructor& err) {
4350                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), path, track.name()) << endmsg;
4351                         goto out;
4352                 }
4353
4354                 srcs.push_back (fsource);
4355         }
4356
4357         /* tell redirects that care that we are about to use a much larger
4358          * blocksize. this will flush all plugins too, so that they are ready
4359          * to be used for this process.
4360          */
4361
4362         need_block_size_reset = true;
4363         track.set_block_size (bounce_chunk_size);
4364         _engine.main_thread()->get_buffers ();
4365
4366         position = start;
4367         to_do = len;
4368         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4369
4370         /* create a set of reasonably-sized buffers */
4371         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4372                 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
4373         }
4374         buffers.set_count (max_proc);
4375
4376         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4377                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4378                 if (afs)
4379                         afs->prepare_for_peakfile_writes ();
4380         }
4381
4382         while (to_do && !itt.cancel) {
4383
4384                 this_chunk = min (to_do, bounce_chunk_size);
4385
4386                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
4387                         goto out;
4388                 }
4389
4390                 start += this_chunk;
4391                 to_do -= this_chunk;
4392                 itt.progress = (float) (1.0 - ((double) to_do / len));
4393
4394                 if (latency_skip >= bounce_chunk_size) {
4395                         latency_skip -= bounce_chunk_size;
4396                         continue;
4397                 }
4398
4399                 const framecnt_t current_chunk = this_chunk - latency_skip;
4400
4401                 uint32_t n = 0;
4402                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4403                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4404
4405                         if (afs) {
4406                                 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
4407                                         goto out;
4408                                 }
4409                         }
4410                 }
4411                 latency_skip = 0;
4412         }
4413
4414         /* post-roll, pick up delayed processor output */
4415         latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
4416
4417         while (latency_skip && !itt.cancel) {
4418                 this_chunk = min (latency_skip, bounce_chunk_size);
4419                 latency_skip -= this_chunk;
4420
4421                 buffers.silence (this_chunk, 0);
4422                 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
4423
4424                 uint32_t n = 0;
4425                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4426                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4427
4428                         if (afs) {
4429                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4430                                         goto out;
4431                                 }
4432                         }
4433                 }
4434         }
4435
4436         if (!itt.cancel) {
4437
4438                 time_t now;
4439                 struct tm* xnow;
4440                 time (&now);
4441                 xnow = localtime (&now);
4442
4443                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4444                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4445
4446                         if (afs) {
4447                                 afs->update_header (position, *xnow, now);
4448                                 afs->flush_header ();
4449                         }
4450                 }
4451
4452                 /* construct a region to represent the bounced material */
4453
4454                 PropertyList plist;
4455
4456                 plist.add (Properties::start, 0);
4457                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4458                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4459
4460                 result = RegionFactory::create (srcs, plist);
4461
4462         }
4463
4464   out:
4465         if (!result) {
4466                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4467                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4468
4469                         if (afs) {
4470                                 afs->mark_for_remove ();
4471                         }
4472
4473                         (*src)->drop_references ();
4474                 }
4475
4476         } else {
4477                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4478                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4479
4480                         if (afs)
4481                                 afs->done_with_peakfile_writes ();
4482                 }
4483         }
4484
4485         _bounce_processing_active = false;
4486
4487         if (need_block_size_reset) {
4488                 _engine.main_thread()->drop_buffers ();
4489                 track.set_block_size (get_block_size());
4490         }
4491
4492         unblock_processing ();
4493
4494         return result;
4495 }
4496
4497 gain_t*
4498 Session::gain_automation_buffer() const
4499 {
4500         return ProcessThread::gain_automation_buffer ();
4501 }
4502
4503 gain_t*
4504 Session::send_gain_automation_buffer() const
4505 {
4506         return ProcessThread::send_gain_automation_buffer ();
4507 }
4508
4509 pan_t**
4510 Session::pan_automation_buffer() const
4511 {
4512         return ProcessThread::pan_automation_buffer ();
4513 }
4514
4515 BufferSet&
4516 Session::get_silent_buffers (ChanCount count)
4517 {
4518         return ProcessThread::get_silent_buffers (count);
4519 }
4520
4521 BufferSet&
4522 Session::get_scratch_buffers (ChanCount count, bool silence)
4523 {
4524         return ProcessThread::get_scratch_buffers (count, silence);
4525 }
4526
4527 BufferSet&
4528 Session::get_route_buffers (ChanCount count, bool silence)
4529 {
4530         return ProcessThread::get_route_buffers (count, silence);
4531 }
4532
4533
4534 BufferSet&
4535 Session::get_mix_buffers (ChanCount count)
4536 {
4537         return ProcessThread::get_mix_buffers (count);
4538 }
4539
4540 uint32_t
4541 Session::ntracks () const
4542 {
4543         uint32_t n = 0;
4544         boost::shared_ptr<RouteList> r = routes.reader ();
4545
4546         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4547                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4548                         ++n;
4549                 }
4550         }
4551
4552         return n;
4553 }
4554
4555 uint32_t
4556 Session::nbusses () const
4557 {
4558         uint32_t n = 0;
4559         boost::shared_ptr<RouteList> r = routes.reader ();
4560
4561         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4562                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4563                         ++n;
4564                 }
4565         }
4566
4567         return n;
4568 }
4569
4570 void
4571 Session::add_automation_list(AutomationList *al)
4572 {
4573         automation_lists[al->id()] = al;
4574 }
4575
4576 /** @return true if there is at least one record-enabled track, otherwise false */
4577 bool
4578 Session::have_rec_enabled_track () const
4579 {
4580         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4581 }
4582
4583 /** Update the state of our rec-enabled tracks flag */
4584 void
4585 Session::update_have_rec_enabled_track ()
4586 {
4587         boost::shared_ptr<RouteList> rl = routes.reader ();
4588         RouteList::iterator i = rl->begin();
4589         while (i != rl->end ()) {
4590
4591                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4592                 if (tr && tr->record_enabled ()) {
4593                         break;
4594                 }
4595
4596                 ++i;
4597         }
4598
4599         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4600
4601         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4602
4603         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4604                 RecordStateChanged (); /* EMIT SIGNAL */
4605         }
4606 }
4607
4608 void
4609 Session::listen_position_changed ()
4610 {
4611         boost::shared_ptr<RouteList> r = routes.reader ();
4612
4613         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4614                 (*i)->listen_position_changed ();
4615         }
4616 }
4617
4618 void
4619 Session::solo_control_mode_changed ()
4620 {
4621         /* cancel all solo or all listen when solo control mode changes */
4622
4623         if (soloing()) {
4624                 set_solo (get_routes(), false);
4625         } else if (listening()) {
4626                 set_listen (get_routes(), false);
4627         }
4628 }
4629
4630 /** Called when a property of one of our route groups changes */
4631 void
4632 Session::route_group_property_changed (RouteGroup* rg)
4633 {
4634         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4635 }
4636
4637 /** Called when a route is added to one of our route groups */
4638 void
4639 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4640 {
4641         RouteAddedToRouteGroup (rg, r);
4642 }
4643
4644 /** Called when a route is removed from one of our route groups */
4645 void
4646 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4647 {
4648         RouteRemovedFromRouteGroup (rg, r);
4649 }
4650
4651 boost::shared_ptr<RouteList>
4652 Session::get_tracks () const
4653 {
4654         boost::shared_ptr<RouteList> rl = routes.reader ();
4655         boost::shared_ptr<RouteList> tl (new RouteList);
4656
4657         for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
4658                 if (boost::dynamic_pointer_cast<Track> (*r)) {
4659                         if (!(*r)->is_auditioner()) {
4660                                 tl->push_back (*r);
4661                         }
4662                 }
4663         }
4664         return tl;
4665 }
4666
4667 boost::shared_ptr<RouteList>
4668 Session::get_routes_with_regions_at (framepos_t const p) const
4669 {
4670         boost::shared_ptr<RouteList> r = routes.reader ();
4671         boost::shared_ptr<RouteList> rl (new RouteList);
4672
4673         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4674                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4675                 if (!tr) {
4676                         continue;
4677                 }
4678
4679                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4680                 if (!pl) {
4681                         continue;
4682                 }
4683
4684                 if (pl->has_region_at (p)) {
4685                         rl->push_back (*i);
4686                 }
4687         }
4688
4689         return rl;
4690 }
4691
4692 void
4693 Session::goto_end ()
4694 {
4695         if (_session_range_location) {
4696                 request_locate (_session_range_location->end(), false);
4697         } else {
4698                 request_locate (0, false);
4699         }
4700 }
4701
4702 void
4703 Session::goto_start ()
4704 {
4705         if (_session_range_location) {
4706                 request_locate (_session_range_location->start(), false);
4707         } else {
4708                 request_locate (0, false);
4709         }
4710 }
4711
4712 framepos_t
4713 Session::current_start_frame () const
4714 {
4715         return _session_range_location ? _session_range_location->start() : 0;
4716 }
4717
4718 framepos_t
4719 Session::current_end_frame () const
4720 {
4721         return _session_range_location ? _session_range_location->end() : 0;
4722 }
4723
4724 void
4725 Session::add_session_range_location (framepos_t start, framepos_t end)
4726 {
4727         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4728         _locations->add (_session_range_location);
4729 }
4730
4731 void
4732 Session::step_edit_status_change (bool yn)
4733 {
4734         bool send = false;
4735
4736         bool val = false;
4737         if (yn) {
4738                 send = (_step_editors == 0);
4739                 val = true;
4740
4741                 _step_editors++;
4742         } else {
4743                 send = (_step_editors == 1);
4744                 val = false;
4745
4746                 if (_step_editors > 0) {
4747                         _step_editors--;
4748                 }
4749         }
4750
4751         if (send) {
4752                 StepEditStatusChange (val);
4753         }
4754 }
4755
4756
4757 void
4758 Session::start_time_changed (framepos_t old)
4759 {
4760         /* Update the auto loop range to match the session range
4761            (unless the auto loop range has been changed by the user)
4762         */
4763
4764         Location* s = _locations->session_range_location ();
4765         if (s == 0) {
4766                 return;
4767         }
4768
4769         Location* l = _locations->auto_loop_location ();
4770
4771         if (l && l->start() == old) {
4772                 l->set_start (s->start(), true);
4773         }
4774 }
4775
4776 void
4777 Session::end_time_changed (framepos_t old)
4778 {
4779         /* Update the auto loop range to match the session range
4780            (unless the auto loop range has been changed by the user)
4781         */
4782
4783         Location* s = _locations->session_range_location ();
4784         if (s == 0) {
4785                 return;
4786         }
4787
4788         Location* l = _locations->auto_loop_location ();
4789
4790         if (l && l->end() == old) {
4791                 l->set_end (s->end(), true);
4792         }
4793 }
4794
4795 std::vector<std::string>
4796 Session::source_search_path (DataType type) const
4797 {
4798         Searchpath sp;
4799
4800         if (session_dirs.size() == 1) {
4801                 switch (type) {
4802                 case DataType::AUDIO:
4803                         sp.push_back (_session_dir->sound_path());
4804                         break;
4805                 case DataType::MIDI:
4806                         sp.push_back (_session_dir->midi_path());
4807                         break;
4808                 }
4809         } else {
4810                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4811                         SessionDirectory sdir (i->path);
4812                         switch (type) {
4813                         case DataType::AUDIO:
4814                                 sp.push_back (sdir.sound_path());
4815                                 break;
4816                         case DataType::MIDI:
4817                                 sp.push_back (sdir.midi_path());
4818                                 break;
4819                         }
4820                 }
4821         }
4822
4823         if (type == DataType::AUDIO) {
4824                 const string sound_path_2X = _session_dir->sound_path_2X();
4825                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4826                         if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
4827                                 sp.push_back (sound_path_2X);
4828                         }
4829                 }
4830         }
4831
4832         // now check the explicit (possibly user-specified) search path
4833
4834         switch (type) {
4835         case DataType::AUDIO:
4836                 sp += Searchpath(config.get_audio_search_path ());
4837                 break;
4838         case DataType::MIDI:
4839                 sp += Searchpath(config.get_midi_search_path ());
4840                 break;
4841         }
4842
4843         return sp;
4844 }
4845
4846 void
4847 Session::ensure_search_path_includes (const string& path, DataType type)
4848 {
4849         Searchpath sp;
4850
4851         if (path == ".") {
4852                 return;
4853         }
4854
4855         switch (type) {
4856         case DataType::AUDIO:
4857                 sp += Searchpath(config.get_audio_search_path ());
4858                 break;
4859         case DataType::MIDI:
4860                 sp += Searchpath (config.get_midi_search_path ());
4861                 break;
4862         }
4863
4864         for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
4865                 /* No need to add this new directory if it has the same inode as
4866                    an existing one; checking inode rather than name prevents duplicated
4867                    directories when we are using symlinks.
4868
4869                    On Windows, I think we could just do if (*i == path) here.
4870                 */
4871                 if (PBD::equivalent_paths (*i, path)) {
4872                         return;
4873                 }
4874         }
4875
4876         sp += path;
4877
4878         switch (type) {
4879         case DataType::AUDIO:
4880                 config.set_audio_search_path (sp.to_string());
4881                 break;
4882         case DataType::MIDI:
4883                 config.set_midi_search_path (sp.to_string());
4884                 break;
4885         }
4886 }
4887
4888 void
4889 Session::remove_dir_from_search_path (const string& dir, DataType type)
4890 {
4891         Searchpath sp;
4892
4893         switch (type) {
4894         case DataType::AUDIO:
4895                 sp = Searchpath(config.get_audio_search_path ());
4896                 break;
4897         case DataType::MIDI:
4898                 sp = Searchpath (config.get_midi_search_path ());
4899                 break;
4900         }
4901
4902         sp -= dir;
4903
4904         switch (type) {
4905         case DataType::AUDIO:
4906                 config.set_audio_search_path (sp.to_string());
4907                 break;
4908         case DataType::MIDI:
4909                 config.set_midi_search_path (sp.to_string());
4910                 break;
4911         }
4912
4913 }
4914
4915 boost::shared_ptr<Speakers>
4916 Session::get_speakers()
4917 {
4918         return _speakers;
4919 }
4920
4921 list<string>
4922 Session::unknown_processors () const
4923 {
4924         list<string> p;
4925
4926         boost::shared_ptr<RouteList> r = routes.reader ();
4927         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4928                 list<string> t = (*i)->unknown_processors ();
4929                 copy (t.begin(), t.end(), back_inserter (p));
4930         }
4931
4932         p.sort ();
4933         p.unique ();
4934
4935         return p;
4936 }
4937
4938 void
4939 Session::update_latency (bool playback)
4940 {
4941         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4942
4943         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4944                 return;
4945         }
4946
4947         boost::shared_ptr<RouteList> r = routes.reader ();
4948         framecnt_t max_latency = 0;
4949
4950         if (playback) {
4951                 /* reverse the list so that we work backwards from the last route to run to the first */
4952                 RouteList* rl = routes.reader().get();
4953                 r.reset (new RouteList (*rl));
4954                 reverse (r->begin(), r->end());
4955         }
4956
4957         /* compute actual latency values for the given direction and store them all in per-port
4958            structures. this will also publish the same values (to JACK) so that computation of latency
4959            for routes can consistently use public latency values.
4960         */
4961
4962         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4963                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4964         }
4965
4966         /* because we latency compensate playback, our published playback latencies should
4967            be the same for all output ports - all material played back by ardour has
4968            the same latency, whether its caused by plugins or by latency compensation. since
4969            these may differ from the values computed above, reset all playback port latencies
4970            to the same value.
4971         */
4972
4973         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4974
4975         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4976                 (*i)->set_public_port_latencies (max_latency, playback);
4977         }
4978
4979         if (playback) {
4980
4981                 post_playback_latency ();
4982
4983         } else {
4984
4985                 post_capture_latency ();
4986         }
4987
4988         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4989 }
4990
4991 void
4992 Session::post_playback_latency ()
4993 {
4994         set_worst_playback_latency ();
4995
4996         boost::shared_ptr<RouteList> r = routes.reader ();
4997
4998         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4999                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5000                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
5001                 }
5002         }
5003
5004         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5005                 (*i)->set_latency_compensation (_worst_track_latency);
5006         }
5007 }
5008
5009 void
5010 Session::post_capture_latency ()
5011 {
5012         set_worst_capture_latency ();
5013
5014         /* reflect any changes in capture latencies into capture offsets
5015          */
5016
5017         boost::shared_ptr<RouteList> rl = routes.reader();
5018         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5019                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5020                 if (tr) {
5021                         tr->set_capture_offset ();
5022                 }
5023         }
5024 }
5025
5026 void
5027 Session::initialize_latencies ()
5028 {
5029         {
5030                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5031                 update_latency (false);
5032                 update_latency (true);
5033         }
5034
5035         set_worst_io_latencies ();
5036 }
5037
5038 void
5039 Session::set_worst_io_latencies ()
5040 {
5041         set_worst_playback_latency ();
5042         set_worst_capture_latency ();
5043 }
5044
5045 void
5046 Session::set_worst_playback_latency ()
5047 {
5048         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5049                 return;
5050         }
5051
5052         _worst_output_latency = 0;
5053
5054         if (!_engine.connected()) {
5055                 return;
5056         }
5057
5058         boost::shared_ptr<RouteList> r = routes.reader ();
5059
5060         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5061                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5062         }
5063
5064         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5065 }
5066
5067 void
5068 Session::set_worst_capture_latency ()
5069 {
5070         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5071                 return;
5072         }
5073
5074         _worst_input_latency = 0;
5075
5076         if (!_engine.connected()) {
5077                 return;
5078         }
5079
5080         boost::shared_ptr<RouteList> r = routes.reader ();
5081
5082         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5083                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
5084         }
5085
5086         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
5087 }
5088
5089 void
5090 Session::update_latency_compensation (bool force_whole_graph)
5091 {
5092         bool some_track_latency_changed = false;
5093
5094         if (_state_of_the_state & (InitialConnecting|Deletion)) {
5095                 return;
5096         }
5097
5098         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
5099
5100         _worst_track_latency = 0;
5101
5102         boost::shared_ptr<RouteList> r = routes.reader ();
5103
5104         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5105                 if (!(*i)->is_auditioner() && ((*i)->active())) {
5106                         framecnt_t tl;
5107                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
5108                                 some_track_latency_changed = true;
5109                         }
5110                         _worst_track_latency = max (tl, _worst_track_latency);
5111                 }
5112         }
5113
5114         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
5115                                                      (some_track_latency_changed ? "yes" : "no")));
5116
5117         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
5118
5119         if (some_track_latency_changed || force_whole_graph)  {
5120                 _engine.update_latencies ();
5121         }
5122
5123
5124         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5125                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5126                 if (!tr) {
5127                         continue;
5128                 }
5129                 tr->set_capture_offset ();
5130         }
5131 }
5132
5133 char
5134 Session::session_name_is_legal (const string& path)
5135 {
5136         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
5137
5138         for (int i = 0; illegal_chars[i]; ++i) {
5139                 if (path.find (illegal_chars[i]) != string::npos) {
5140                         return illegal_chars[i];
5141                 }
5142         }
5143
5144         return 0;
5145 }
5146
5147 uint32_t
5148 Session::next_control_id () const
5149 {
5150         int subtract = 0;
5151
5152         /* the monitor bus remote ID is in a different
5153          * "namespace" than regular routes. its existence doesn't
5154          * affect normal (low) numbered routes.
5155          */
5156
5157         if (_monitor_out) {
5158                 subtract++;
5159         }
5160
5161         return nroutes() - subtract;
5162 }
5163
5164 void
5165 Session::notify_remote_id_change ()
5166 {
5167         if (deletion_in_progress()) {
5168                 return;
5169         }
5170
5171         switch (Config->get_remote_model()) {
5172         case MixerOrdered:
5173                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
5174                 break;
5175         default:
5176                 break;
5177         }
5178 }
5179
5180 void
5181 Session::sync_order_keys ()
5182 {
5183         if (deletion_in_progress()) {
5184                 return;
5185         }
5186
5187         /* tell everyone that something has happened to the sort keys
5188            and let them sync up with the change(s)
5189            this will give objects that manage the sort order keys the
5190            opportunity to keep them in sync if they wish to.
5191         */
5192
5193         DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
5194
5195         reassign_track_numbers();
5196
5197         Route::SyncOrderKeys (); /* EMIT SIGNAL */
5198
5199         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
5200 }
5201
5202 bool
5203 Session::operation_in_progress (GQuark op) const
5204 {
5205         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
5206 }
5207
5208 boost::shared_ptr<Port>
5209 Session::ltc_input_port () const
5210 {
5211         return _ltc_input->nth (0);
5212 }
5213
5214 boost::shared_ptr<Port>
5215 Session::ltc_output_port () const
5216 {
5217         return _ltc_output->nth (0);
5218 }
5219
5220 void
5221 Session::reconnect_ltc_input ()
5222 {
5223         if (_ltc_input) {
5224
5225                 string src = Config->get_ltc_source_port();
5226
5227                 _ltc_input->disconnect (this);
5228
5229                 if (src != _("None") && !src.empty())  {
5230                         _ltc_input->nth (0)->connect (src);
5231                 }
5232         }
5233 }
5234
5235 void
5236 Session::reconnect_ltc_output ()
5237 {
5238         if (_ltc_output) {
5239
5240 #if 0
5241                 string src = Config->get_ltc_sink_port();
5242
5243                 _ltc_output->disconnect (this);
5244
5245                 if (src != _("None") && !src.empty())  {
5246                         _ltc_output->nth (0)->connect (src);
5247                 }
5248 #endif
5249         }
5250 }