libs/ardour/session.cc

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