2 Copyright (C) 1999-2010 Paul Davis
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.
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.
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.
27 #include <cstdio> /* sprintf(3) ... grrr */
33 #include <glibmm/threads.h>
34 #include <glibmm/miscutils.h>
35 #include <glibmm/fileutils.h>
37 #include <boost/algorithm/string/erase.hpp>
39 #include "pbd/error.h"
40 #include "pbd/boost_debug.h"
41 #include "pbd/pathscanner.h"
42 #include "pbd/stl_delete.h"
43 #include "pbd/basename.h"
44 #include "pbd/stacktrace.h"
45 #include "pbd/file_utils.h"
46 #include "pbd/convert.h"
47 #include "pbd/unwind.h"
48 #include "pbd/search_path.h"
50 #include "ardour/amp.h"
51 #include "ardour/analyser.h"
52 #include "ardour/async_midi_port.h"
53 #include "ardour/audio_buffer.h"
54 #include "ardour/audio_diskstream.h"
55 #include "ardour/audio_port.h"
56 #include "ardour/audio_track.h"
57 #include "ardour/audioengine.h"
58 #include "ardour/audiofilesource.h"
59 #include "ardour/auditioner.h"
60 #include "ardour/buffer_manager.h"
61 #include "ardour/buffer_set.h"
62 #include "ardour/bundle.h"
63 #include "ardour/butler.h"
64 #include "ardour/click.h"
65 #include "ardour/control_protocol_manager.h"
66 #include "ardour/data_type.h"
67 #include "ardour/debug.h"
68 #include "ardour/filename_extensions.h"
69 #include "ardour/graph.h"
70 #include "ardour/midiport_manager.h"
71 #include "ardour/midi_track.h"
72 #include "ardour/midi_ui.h"
73 #include "ardour/operations.h"
74 #include "ardour/playlist.h"
75 #include "ardour/plugin.h"
76 #include "ardour/plugin_insert.h"
77 #include "ardour/process_thread.h"
78 #include "ardour/rc_configuration.h"
79 #include "ardour/recent_sessions.h"
80 #include "ardour/region.h"
81 #include "ardour/region_factory.h"
82 #include "ardour/route_graph.h"
83 #include "ardour/route_group.h"
84 #include "ardour/send.h"
85 #include "ardour/session.h"
86 #include "ardour/session_directory.h"
87 #include "ardour/session_playlists.h"
88 #include "ardour/smf_source.h"
89 #include "ardour/source_factory.h"
90 #include "ardour/speakers.h"
91 #include "ardour/utils.h"
93 #include "midi++/port.h"
94 #include "midi++/mmc.h"
105 using namespace ARDOUR;
108 bool Session::_disable_all_loaded_plugins = false;
110 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
111 PBD::Signal1<void,std::string> Session::Dialog;
112 PBD::Signal0<int> Session::AskAboutPendingState;
113 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
114 PBD::Signal0<void> Session::SendFeedback;
115 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
117 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
118 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
119 PBD::Signal2<void,std::string, std::string> Session::Exported;
120 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
121 PBD::Signal0<void> Session::Quit;
122 PBD::Signal0<void> Session::FeedbackDetected;
123 PBD::Signal0<void> Session::SuccessfulGraphSort;
124 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
126 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
127 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
129 /** @param snapshot_name Snapshot name, without .ardour suffix */
130 Session::Session (AudioEngine &eng,
131 const string& fullpath,
132 const string& snapshot_name,
133 BusProfile* bus_profile,
135 : playlists (new SessionPlaylists)
137 , process_function (&Session::process_with_events)
138 , waiting_for_sync_offset (false)
139 , _base_frame_rate (0)
140 , _current_frame_rate (0)
141 , _nominal_frame_rate (0)
142 , transport_sub_state (0)
143 , _record_status (Disabled)
144 , _transport_frame (0)
145 , _session_range_location (0)
148 , _transport_speed (0)
149 , _default_transport_speed (1.0)
150 , _last_transport_speed (0)
151 , _target_transport_speed (0.0)
152 , auto_play_legal (false)
153 , _last_slave_transport_frame (0)
154 , maximum_output_latency (0)
155 , _requested_return_frame (-1)
156 , current_block_size (0)
157 , _worst_output_latency (0)
158 , _worst_input_latency (0)
159 , _worst_track_latency (0)
160 , _have_captured (false)
163 , _non_soloed_outs_muted (false)
165 , _solo_isolated_cnt (0)
167 , _was_seamless (Config->get_seamless_loop ())
168 , _under_nsm_control (false)
169 , delta_accumulator_cnt (0)
170 , average_slave_delta (1800) // !!! why 1800 ???
172 , have_first_delta_accumulator (false)
173 , _slave_state (Stopped)
174 , post_export_sync (false)
175 , post_export_position (0)
177 , _export_started (false)
178 , _export_rolling (false)
179 , _pre_export_mmc_enabled (false)
180 , _name (snapshot_name)
182 , _send_qf_mtc (false)
183 , _pframes_since_last_mtc (0)
184 , session_midi_feedback (0)
186 , loop_changing (false)
188 , _session_dir (new SessionDirectory (fullpath))
189 , _current_snapshot_name (snapshot_name)
191 , state_was_pending (false)
192 , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
193 , _last_roll_location (0)
194 , _last_roll_or_reversal_location (0)
195 , _last_record_location (0)
196 , pending_locate_roll (false)
197 , pending_locate_frame (0)
198 , pending_locate_flush (false)
199 , pending_abort (false)
200 , pending_auto_loop (false)
201 , _butler (new Butler (*this))
202 , _post_transport_work (0)
203 , cumulative_rf_motion (0)
205 , _locations (new Locations (*this))
207 , outbound_mtc_timecode_frame (0)
208 , next_quarter_frame_to_send (-1)
209 , _frames_per_timecode_frame (0)
210 , _frames_per_hour (0)
211 , _timecode_frames_per_hour (0)
212 , last_timecode_valid (false)
213 , last_timecode_when (0)
214 , _send_timecode_update (false)
226 , ltc_timecode_offset (0)
227 , ltc_timecode_negative_offset (false)
228 , midi_control_ui (0)
230 , _all_route_group (new RouteGroup (*this, "all"))
231 , routes (new RouteList)
232 , _adding_routes_in_progress (false)
233 , destructive_index (0)
234 , solo_update_disabled (false)
235 , default_fade_steepness (0)
236 , default_fade_msecs (0)
237 , _total_free_4k_blocks (0)
238 , _total_free_4k_blocks_uncertain (false)
239 , no_questions_about_missing_files (false)
242 , _bundles (new BundleList)
243 , _bundle_xml_node (0)
247 , click_emphasis_data (0)
249 , click_emphasis_length (0)
250 , _clicks_cleared (0)
251 , _play_range (false)
253 , first_file_data_format_reset (true)
254 , first_file_header_format_reset (true)
255 , have_looped (false)
256 , _have_rec_enabled_track (false)
258 , _suspend_timecode_transmission (0)
259 , _speakers (new Speakers)
260 , ignore_route_processor_changes (false)
266 pre_engine_init (fullpath);
269 if (ensure_engine (sr)) {
271 throw failed_constructor ();
274 if (create (mix_template, bus_profile)) {
276 throw failed_constructor ();
279 /* if a mix template was provided, then ::create() will
280 * have copied it into the session and we need to load it
281 * so that we have the state ready for ::set_state()
282 * after the engine is started.
284 * Note that we do NOT try to get the sample rate from
285 * the template at this time, though doing so would
286 * be easy if we decided this was an appropriate part
290 if (!mix_template.empty() && load_state (_current_snapshot_name)) {
291 throw failed_constructor ();
296 if (load_state (_current_snapshot_name)) {
297 throw failed_constructor ();
300 /* try to get sample rate from XML state so that we
301 * can influence the SR if we set up the audio
306 const XMLProperty* prop;
307 if ((prop = state_tree->root()->property (X_("sample-rate"))) != 0) {
308 sr = atoi (prop->value());
312 if (ensure_engine (sr)) {
314 throw failed_constructor ();
318 if (post_engine_init ()) {
320 throw failed_constructor ();
323 store_recent_sessions (_name, _path);
325 bool was_dirty = dirty();
327 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
329 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
330 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
333 DirtyChanged (); /* EMIT SIGNAL */
336 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
337 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
341 /* hook us up to the engine since we are now completely constructed */
343 BootMessage (_("Connect to engine"));
345 _engine.set_session (this);
346 _engine.reset_timebase ();
348 BootMessage (_("Session loading complete"));
361 Session::ensure_engine (uint32_t desired_sample_rate)
363 if (_engine.current_backend() == 0) {
364 /* backend is unknown ... */
365 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
366 if (r.get_value_or (-1) != 0) {
369 } else if (_engine.setup_required()) {
370 /* backend is known, but setup is needed */
371 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
372 if (r.get_value_or (-1) != 0) {
375 } else if (!_engine.running()) {
376 if (_engine.start()) {
381 /* at this point the engine should be running
384 if (!_engine.running()) {
388 return immediately_post_engine ();
393 Session::immediately_post_engine ()
395 /* Do various initializations that should take place directly after we
396 * know that the engine is running, but before we either create a
397 * session or set state for an existing one.
400 if (how_many_dsp_threads () > 1) {
401 /* For now, only create the graph if we are using >1 DSP threads, as
402 it is a bit slower than the old code with 1 thread.
404 _process_graph.reset (new Graph (*this));
407 /* every time we reconnect, recompute worst case output latencies */
409 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
411 if (synced_to_engine()) {
412 _engine.transport_stop ();
415 if (config.get_jack_time_master()) {
416 _engine.transport_locate (_transport_frame);
420 BootMessage (_("Set up LTC"));
422 BootMessage (_("Set up Click"));
424 BootMessage (_("Set up standard connections"));
428 catch (failed_constructor& err) {
438 vector<void*> debug_pointers;
440 /* if we got to here, leaving pending capture state around
444 remove_pending_capture_state ();
446 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
448 /* disconnect from any and all signals that we are connected to */
452 _engine.remove_session ();
454 /* deregister all ports - there will be no process or any other
455 * callbacks from the engine any more.
458 Port::PortDrop (); /* EMIT SIGNAL */
462 /* clear history so that no references to objects are held any more */
466 /* clear state tree so that no references to objects are held any more */
470 /* reset dynamic state version back to default */
472 Stateful::loading_state_version = 0;
474 _butler->drop_references ();
478 delete midi_control_ui;
479 delete _all_route_group;
481 if (click_data != default_click) {
482 delete [] click_data;
485 if (click_emphasis_data != default_click_emphasis) {
486 delete [] click_emphasis_data;
491 /* clear out any pending dead wood from RCU managed objects */
496 AudioDiskstream::free_working_buffers();
498 /* tell everyone who is still standing that we're about to die */
501 /* tell everyone to drop references and delete objects as we go */
503 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
504 RegionFactory::delete_all_regions ();
506 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
508 /* reset these three references to special routes before we do the usual route delete thing */
511 _master_out.reset ();
512 _monitor_out.reset ();
515 RCUWriter<RouteList> writer (routes);
516 boost::shared_ptr<RouteList> r = writer.get_copy ();
518 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
519 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
520 (*i)->drop_references ();
524 /* writer goes out of scope and updates master */
528 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
529 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
530 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
531 i->second->drop_references ();
536 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
537 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
542 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
545 delete _mmc; _mmc = 0;
546 delete _midi_ports; _midi_ports = 0;
547 delete _locations; _locations = 0;
549 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
551 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
552 boost_debug_list_ptrs ();
557 Session::setup_ltc ()
561 _ltc_input.reset (new IO (*this, _("LTC In"), IO::Input));
562 _ltc_output.reset (new IO (*this, _("LTC Out"), IO::Output));
564 if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-In")) != 0) {
565 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
568 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
569 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
571 reconnect_ltc_input ();
574 if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-Out")) != 0) {
575 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
578 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
579 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
581 reconnect_ltc_output ();
584 /* fix up names of LTC ports because we don't want the normal
585 * IO style of NAME/TYPE-{in,out}N
588 _ltc_input->nth (0)->set_name (_("LTC-in"));
589 _ltc_output->nth (0)->set_name (_("LTC-out"));
593 Session::setup_click ()
596 _click_io.reset (new ClickIO (*this, "click"));
597 _click_gain.reset (new Amp (*this));
598 _click_gain->activate ();
600 setup_click_state (*state_tree->root());
605 Session::setup_click_state (const XMLNode& node)
607 const XMLNode* child = 0;
609 if ((child = find_named_node (node, "Click")) != 0) {
611 /* existing state for Click */
614 if (Stateful::loading_state_version < 3000) {
615 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
617 const XMLNodeList& children (child->children());
618 XMLNodeList::const_iterator i = children.begin();
619 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
621 if (i != children.end()) {
622 c = _click_gain->set_state (**i, Stateful::loading_state_version);
628 _clicking = Config->get_clicking ();
632 error << _("could not setup Click I/O") << endmsg;
639 /* default state for Click: dual-mono to first 2 physical outputs */
642 _engine.get_physical_outputs (DataType::AUDIO, outs);
644 for (uint32_t physport = 0; physport < 2; ++physport) {
645 if (outs.size() > physport) {
646 if (_click_io->add_port (outs[physport], this)) {
647 // relax, even though its an error
652 if (_click_io->n_ports () > ChanCount::ZERO) {
653 _clicking = Config->get_clicking ();
659 Session::setup_bundles ()
661 vector<string> inputs[DataType::num_types];
662 vector<string> outputs[DataType::num_types];
663 for (uint32_t i = 0; i < DataType::num_types; ++i) {
664 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
665 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
668 /* Create a set of Bundle objects that map
669 to the physical I/O currently available. We create both
670 mono and stereo bundles, so that the common cases of mono
671 and stereo tracks get bundles to put in their mixer strip
672 in / out menus. There may be a nicer way of achieving that;
673 it doesn't really scale that well to higher channel counts
676 /* mono output bundles */
678 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
680 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
682 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
683 c->add_channel (_("mono"), DataType::AUDIO);
684 c->set_port (0, outputs[DataType::AUDIO][np]);
689 /* stereo output bundles */
691 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
692 if (np + 1 < outputs[DataType::AUDIO].size()) {
694 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
695 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
696 c->add_channel (_("L"), DataType::AUDIO);
697 c->set_port (0, outputs[DataType::AUDIO][np]);
698 c->add_channel (_("R"), DataType::AUDIO);
699 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
705 /* mono input bundles */
707 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
709 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
711 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
712 c->add_channel (_("mono"), DataType::AUDIO);
713 c->set_port (0, inputs[DataType::AUDIO][np]);
718 /* stereo input bundles */
720 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
721 if (np + 1 < inputs[DataType::AUDIO].size()) {
723 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
725 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
726 c->add_channel (_("L"), DataType::AUDIO);
727 c->set_port (0, inputs[DataType::AUDIO][np]);
728 c->add_channel (_("R"), DataType::AUDIO);
729 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
735 /* MIDI input bundles */
737 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
738 string n = inputs[DataType::MIDI][np];
739 boost::erase_first (n, X_("alsa_pcm:"));
741 boost::shared_ptr<Bundle> c (new Bundle (n, false));
742 c->add_channel ("", DataType::MIDI);
743 c->set_port (0, inputs[DataType::MIDI][np]);
747 /* MIDI output bundles */
749 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
750 string n = outputs[DataType::MIDI][np];
751 boost::erase_first (n, X_("alsa_pcm:"));
753 boost::shared_ptr<Bundle> c (new Bundle (n, true));
754 c->add_channel ("", DataType::MIDI);
755 c->set_port (0, outputs[DataType::MIDI][np]);
762 Session::auto_connect_master_bus ()
764 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
768 /* if requested auto-connect the outputs to the first N physical ports.
771 uint32_t limit = _master_out->n_outputs().n_total();
772 vector<string> outputs[DataType::num_types];
774 for (uint32_t i = 0; i < DataType::num_types; ++i) {
775 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
778 for (uint32_t n = 0; n < limit; ++n) {
779 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
781 if (outputs[p->type()].size() > n) {
782 connect_to = outputs[p->type()][n];
785 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
786 if (_master_out->output()->connect (p, connect_to, this)) {
787 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
796 Session::remove_monitor_section ()
802 /* force reversion to Solo-In-Place */
803 Config->set_solo_control_is_listen_control (false);
806 /* Hold process lock while doing this so that we don't hear bits and
807 * pieces of audio as we work on each route.
810 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
812 /* Connect tracks to monitor section. Note that in an
813 existing session, the internal sends will already exist, but we want the
814 routes to notice that they connect to the control out specifically.
818 boost::shared_ptr<RouteList> r = routes.reader ();
819 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
821 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
823 if ((*x)->is_monitor()) {
825 } else if ((*x)->is_master()) {
828 (*x)->remove_aux_or_listen (_monitor_out);
833 remove_route (_monitor_out);
834 auto_connect_master_bus ();
838 Session::add_monitor_section ()
842 if (_monitor_out || !_master_out) {
846 boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
852 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
853 // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
856 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
857 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
858 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
862 add_routes (rl, false, false, false);
864 assert (_monitor_out);
866 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
867 are undefined, at best.
870 uint32_t limit = _monitor_out->n_inputs().n_audio();
874 /* connect the inputs to the master bus outputs. this
875 * represents a separate data feed from the internal sends from
876 * each route. as of jan 2011, it allows the monitor section to
877 * conditionally ignore either the internal sends or the normal
878 * input feed, but we should really find a better way to do
882 _master_out->output()->disconnect (this);
884 for (uint32_t n = 0; n < limit; ++n) {
885 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
886 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
889 string connect_to = o->name();
890 if (_monitor_out->input()->connect (p, connect_to, this)) {
891 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
899 /* if monitor section is not connected, connect it to physical outs
902 if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
904 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
906 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
909 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
911 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
912 Config->get_monitor_bus_preferred_bundle())
918 /* Monitor bus is audio only */
920 vector<string> outputs[DataType::num_types];
922 for (uint32_t i = 0; i < DataType::num_types; ++i) {
923 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
926 uint32_t mod = outputs[DataType::AUDIO].size();
927 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
931 for (uint32_t n = 0; n < limit; ++n) {
933 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
935 if (outputs[DataType::AUDIO].size() > (n % mod)) {
936 connect_to = outputs[DataType::AUDIO][n % mod];
939 if (!connect_to.empty()) {
940 if (_monitor_out->output()->connect (p, connect_to, this)) {
941 error << string_compose (
942 _("cannot connect control output %1 to %2"),
953 /* Hold process lock while doing this so that we don't hear bits and
954 * pieces of audio as we work on each route.
957 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
959 /* Connect tracks to monitor section. Note that in an
960 existing session, the internal sends will already exist, but we want the
961 routes to notice that they connect to the control out specifically.
965 boost::shared_ptr<RouteList> rls = routes.reader ();
967 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
969 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
971 if ((*x)->is_monitor()) {
973 } else if ((*x)->is_master()) {
976 (*x)->enable_monitor_send ();
982 Session::hookup_io ()
984 /* stop graph reordering notifications from
985 causing resorts, etc.
988 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
992 /* we delay creating the auditioner till now because
993 it makes its own connections to ports.
997 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
999 throw failed_constructor ();
1001 a->use_new_diskstream ();
1005 catch (failed_constructor& err) {
1006 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1010 /* load bundles, which we may have postponed earlier on */
1011 if (_bundle_xml_node) {
1012 load_bundles (*_bundle_xml_node);
1013 delete _bundle_xml_node;
1016 /* Tell all IO objects to connect themselves together */
1018 IO::enable_connecting ();
1020 /* Now tell all "floating" ports to connect to whatever
1021 they should be connected to.
1024 AudioEngine::instance()->reconnect_ports ();
1026 /* Anyone who cares about input state, wake up and do something */
1028 IOConnectionsComplete (); /* EMIT SIGNAL */
1030 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1032 /* now handle the whole enchilada as if it was one
1033 graph reorder event.
1038 /* update the full solo state, which can't be
1039 correctly determined on a per-route basis, but
1040 needs the global overview that only the session
1044 update_route_solo_state ();
1048 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1050 boost::shared_ptr<Track> track = wp.lock ();
1055 boost::shared_ptr<Playlist> playlist;
1057 if ((playlist = track->playlist()) != 0) {
1058 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1059 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1060 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1065 Session::record_enabling_legal () const
1067 /* this used to be in here, but survey says.... we don't need to restrict it */
1068 // if (record_status() == Recording) {
1072 if (Config->get_all_safe()) {
1079 Session::set_track_monitor_input_status (bool yn)
1081 boost::shared_ptr<RouteList> rl = routes.reader ();
1082 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1083 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1084 if (tr && tr->record_enabled ()) {
1085 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1086 tr->request_input_monitoring (yn);
1092 Session::auto_punch_start_changed (Location* location)
1094 replace_event (SessionEvent::PunchIn, location->start());
1096 if (get_record_enabled() && config.get_punch_in()) {
1097 /* capture start has been changed, so save new pending state */
1098 save_state ("", true);
1103 Session::auto_punch_end_changed (Location* location)
1105 framepos_t when_to_stop = location->end();
1106 // when_to_stop += _worst_output_latency + _worst_input_latency;
1107 replace_event (SessionEvent::PunchOut, when_to_stop);
1111 Session::auto_punch_changed (Location* location)
1113 framepos_t when_to_stop = location->end();
1115 replace_event (SessionEvent::PunchIn, location->start());
1116 //when_to_stop += _worst_output_latency + _worst_input_latency;
1117 replace_event (SessionEvent::PunchOut, when_to_stop);
1120 /** @param loc A loop location.
1121 * @param pos Filled in with the start time of the required fade-out (in session frames).
1122 * @param length Filled in with the length of the required fade-out.
1125 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1127 pos = max (loc->start(), loc->end() - 64);
1128 length = loc->end() - pos;
1132 Session::auto_loop_changed (Location* location)
1134 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1137 auto_loop_declick_range (location, dcp, dcl);
1138 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1140 if (transport_rolling() && play_loop) {
1143 // if (_transport_frame > location->end()) {
1145 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1146 // relocate to beginning of loop
1147 clear_events (SessionEvent::LocateRoll);
1149 request_locate (location->start(), true);
1152 else if (Config->get_seamless_loop() && !loop_changing) {
1154 // schedule a locate-roll to refill the diskstreams at the
1155 // previous loop end
1156 loop_changing = true;
1158 if (location->end() > last_loopend) {
1159 clear_events (SessionEvent::LocateRoll);
1160 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1167 last_loopend = location->end();
1171 Session::set_auto_punch_location (Location* location)
1175 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1176 punch_connections.drop_connections();
1177 existing->set_auto_punch (false, this);
1178 remove_event (existing->start(), SessionEvent::PunchIn);
1179 clear_events (SessionEvent::PunchOut);
1180 auto_punch_location_changed (0);
1185 if (location == 0) {
1189 if (location->end() <= location->start()) {
1190 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1194 punch_connections.drop_connections ();
1196 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
1197 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
1198 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
1200 location->set_auto_punch (true, this);
1202 auto_punch_changed (location);
1204 auto_punch_location_changed (location);
1208 Session::set_auto_loop_location (Location* location)
1212 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1213 loop_connections.drop_connections ();
1214 existing->set_auto_loop (false, this);
1215 remove_event (existing->end(), SessionEvent::AutoLoop);
1218 auto_loop_declick_range (existing, dcp, dcl);
1219 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1220 auto_loop_location_changed (0);
1225 if (location == 0) {
1229 if (location->end() <= location->start()) {
1230 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1234 last_loopend = location->end();
1236 loop_connections.drop_connections ();
1238 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1239 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1240 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1242 location->set_auto_loop (true, this);
1244 /* take care of our stuff first */
1246 auto_loop_changed (location);
1248 /* now tell everyone else */
1250 auto_loop_location_changed (location);
1254 Session::locations_added (Location *)
1260 Session::locations_changed ()
1262 _locations->apply (*this, &Session::handle_locations_changed);
1266 Session::handle_locations_changed (Locations::LocationList& locations)
1268 Locations::LocationList::iterator i;
1270 bool set_loop = false;
1271 bool set_punch = false;
1273 for (i = locations.begin(); i != locations.end(); ++i) {
1277 if (location->is_auto_punch()) {
1278 set_auto_punch_location (location);
1281 if (location->is_auto_loop()) {
1282 set_auto_loop_location (location);
1286 if (location->is_session_range()) {
1287 _session_range_location = location;
1292 set_auto_loop_location (0);
1295 set_auto_punch_location (0);
1302 Session::enable_record ()
1304 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1305 /* no recording at anything except normal speed */
1310 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1312 if (rs == Recording) {
1316 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1318 _last_record_location = _transport_frame;
1319 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1321 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1322 set_track_monitor_input_status (true);
1325 RecordStateChanged ();
1332 Session::disable_record (bool rt_context, bool force)
1336 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1338 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1339 g_atomic_int_set (&_record_status, Disabled);
1340 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1342 if (rs == Recording) {
1343 g_atomic_int_set (&_record_status, Enabled);
1347 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1348 set_track_monitor_input_status (false);
1351 RecordStateChanged (); /* emit signal */
1354 remove_pending_capture_state ();
1360 Session::step_back_from_record ()
1362 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1364 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1365 set_track_monitor_input_status (false);
1368 RecordStateChanged (); /* emit signal */
1373 Session::maybe_enable_record ()
1375 if (_step_editors > 0) {
1379 g_atomic_int_set (&_record_status, Enabled);
1381 /* This function is currently called from somewhere other than an RT thread.
1382 This save_state() call therefore doesn't impact anything. Doing it here
1383 means that we save pending state of which sources the next record will use,
1384 which gives us some chance of recovering from a crash during the record.
1387 save_state ("", true);
1389 if (_transport_speed) {
1390 if (!config.get_punch_in()) {
1394 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1395 RecordStateChanged (); /* EMIT SIGNAL */
1402 Session::audible_frame () const
1408 /* the first of these two possible settings for "offset"
1409 mean that the audible frame is stationary until
1410 audio emerges from the latency compensation
1413 the second means that the audible frame is stationary
1414 until audio would emerge from a physical port
1415 in the absence of any plugin latency compensation
1418 offset = worst_playback_latency ();
1420 if (offset > current_block_size) {
1421 offset -= current_block_size;
1423 /* XXX is this correct? if we have no external
1424 physical connections and everything is internal
1425 then surely this is zero? still, how
1426 likely is that anyway?
1428 offset = current_block_size;
1431 if (synced_to_engine()) {
1432 tf = _engine.transport_frame();
1434 tf = _transport_frame;
1439 if (!non_realtime_work_pending()) {
1443 /* Check to see if we have passed the first guaranteed
1444 audible frame past our last start position. if not,
1445 return that last start point because in terms
1446 of audible frames, we have not moved yet.
1448 `Start position' in this context means the time we last
1449 either started, located, or changed transport direction.
1452 if (_transport_speed > 0.0f) {
1454 if (!play_loop || !have_looped) {
1455 if (tf < _last_roll_or_reversal_location + offset) {
1456 return _last_roll_or_reversal_location;
1464 } else if (_transport_speed < 0.0f) {
1466 /* XXX wot? no backward looping? */
1468 if (tf > _last_roll_or_reversal_location - offset) {
1469 return _last_roll_or_reversal_location;
1481 Session::set_frame_rate (framecnt_t frames_per_second)
1483 /** \fn void Session::set_frame_size(framecnt_t)
1484 the AudioEngine object that calls this guarantees
1485 that it will not be called while we are also in
1486 ::process(). Its fine to do things that block
1490 _base_frame_rate = frames_per_second;
1491 _nominal_frame_rate = frames_per_second;
1497 // XXX we need some equivalent to this, somehow
1498 // SndFileSource::setup_standard_crossfades (frames_per_second);
1502 /* XXX need to reset/reinstantiate all LADSPA plugins */
1506 Session::set_block_size (pframes_t nframes)
1508 /* the AudioEngine guarantees
1509 that it will not be called while we are also in
1510 ::process(). It is therefore fine to do things that block
1515 current_block_size = nframes;
1519 boost::shared_ptr<RouteList> r = routes.reader ();
1521 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1522 (*i)->set_block_size (nframes);
1525 boost::shared_ptr<RouteList> rl = routes.reader ();
1526 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1527 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1529 tr->set_block_size (nframes);
1533 set_worst_io_latencies ();
1539 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1541 boost::shared_ptr<Route> r2;
1543 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1544 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1548 /* make a copy of the existing list of routes that feed r1 */
1550 Route::FedBy existing (r1->fed_by());
1552 /* for each route that feeds r1, recurse, marking it as feeding
1556 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1557 if (!(r2 = i->r.lock ())) {
1558 /* (*i) went away, ignore it */
1562 /* r2 is a route that feeds r1 which somehow feeds base. mark
1563 base as being fed by r2
1566 rbase->add_fed_by (r2, i->sends_only);
1570 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1574 if (r1->feeds (r2) && r2->feeds (r1)) {
1578 /* now recurse, so that we can mark base as being fed by
1579 all routes that feed r2
1582 trace_terminal (r2, rbase);
1589 Session::resort_routes ()
1591 /* don't do anything here with signals emitted
1592 by Routes during initial setup or while we
1593 are being destroyed.
1596 if (_state_of_the_state & (InitialConnecting | Deletion)) {
1601 RCUWriter<RouteList> writer (routes);
1602 boost::shared_ptr<RouteList> r = writer.get_copy ();
1603 resort_routes_using (r);
1604 /* writer goes out of scope and forces update */
1608 boost::shared_ptr<RouteList> rl = routes.reader ();
1609 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1610 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1612 const Route::FedBy& fb ((*i)->fed_by());
1614 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1615 boost::shared_ptr<Route> sf = f->r.lock();
1617 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1625 /** This is called whenever we need to rebuild the graph of how we will process
1627 * @param r List of routes, in any order.
1631 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1633 /* We are going to build a directed graph of our routes;
1634 this is where the edges of that graph are put.
1639 /* Go through all routes doing two things:
1641 * 1. Collect the edges of the route graph. Each of these edges
1642 * is a pair of routes, one of which directly feeds the other
1643 * either by a JACK connection or by an internal send.
1645 * 2. Begin the process of making routes aware of which other
1646 * routes directly or indirectly feed them. This information
1647 * is used by the solo code.
1650 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1652 /* Clear out the route's list of direct or indirect feeds */
1653 (*i)->clear_fed_by ();
1655 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1657 bool via_sends_only;
1659 /* See if this *j feeds *i according to the current state of the JACK
1660 connections and internal sends.
1662 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1663 /* add the edge to the graph (part #1) */
1664 edges.add (*j, *i, via_sends_only);
1665 /* tell the route (for part #2) */
1666 (*i)->add_fed_by (*j, via_sends_only);
1671 /* Attempt a topological sort of the route graph */
1672 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1674 if (sorted_routes) {
1675 /* We got a satisfactory topological sort, so there is no feedback;
1678 Note: the process graph rechain does not require a
1679 topologically-sorted list, but hey ho.
1681 if (_process_graph) {
1682 _process_graph->rechain (sorted_routes, edges);
1685 _current_route_graph = edges;
1687 /* Complete the building of the routes' lists of what directly
1688 or indirectly feeds them.
1690 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1691 trace_terminal (*i, *i);
1694 *r = *sorted_routes;
1697 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1698 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1699 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1700 (*i)->name(), (*i)->order_key (MixerSort)));
1704 SuccessfulGraphSort (); /* EMIT SIGNAL */
1707 /* The topological sort failed, so we have a problem. Tell everyone
1708 and stick to the old graph; this will continue to be processed, so
1709 until the feedback is fixed, what is played back will not quite
1710 reflect what is actually connected. Note also that we do not
1711 do trace_terminal here, as it would fail due to an endless recursion,
1712 so the solo code will think that everything is still connected
1716 FeedbackDetected (); /* EMIT SIGNAL */
1721 /** Find a route name starting with \a base, maybe followed by the
1722 * lowest \a id. \a id will always be added if \a definitely_add_number
1723 * is true on entry; otherwise it will only be added if required
1724 * to make the name unique.
1726 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1727 * The available route name with the lowest ID will be used, and \a id
1728 * will be set to the ID.
1730 * \return false if a route name could not be found, and \a track_name
1731 * and \a id do not reflect a free route name.
1734 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1736 if (!definitely_add_number && route_by_name (base) == 0) {
1737 /* juse use the base */
1738 snprintf (name, name_len, "%s", base.c_str());
1743 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1745 if (route_by_name (name) == 0) {
1751 } while (id < (UINT_MAX-1));
1756 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1758 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1760 in = ChanCount::ZERO;
1761 out = ChanCount::ZERO;
1763 boost::shared_ptr<RouteList> r = routes.reader ();
1765 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1766 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1767 if (tr && !tr->is_auditioner()) {
1768 in += tr->n_inputs();
1769 out += tr->n_outputs();
1774 /** Caller must not hold process lock
1775 * @param name_template string to use for the start of the name, or "" to use "MIDI".
1776 * @param instrument plugin info for the instrument to insert pre-fader, if any
1778 list<boost::shared_ptr<MidiTrack> >
1779 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1780 TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1782 char track_name[32];
1783 uint32_t track_id = 0;
1785 RouteList new_routes;
1786 list<boost::shared_ptr<MidiTrack> > ret;
1788 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1791 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1792 error << "cannot find name for new midi track" << endmsg;
1796 boost::shared_ptr<MidiTrack> track;
1799 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1801 if (track->init ()) {
1805 track->use_new_diskstream();
1807 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1808 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1811 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1812 if (track->input()->ensure_io (input, false, this)) {
1813 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1817 if (track->output()->ensure_io (output, false, this)) {
1818 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1823 track->non_realtime_input_change();
1826 route_group->add (track);
1829 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1831 if (Config->get_remote_model() == UserOrdered) {
1832 track->set_remote_control_id (next_control_id());
1835 new_routes.push_back (track);
1836 ret.push_back (track);
1839 catch (failed_constructor &err) {
1840 error << _("Session: could not create new midi track.") << endmsg;
1844 catch (AudioEngine::PortRegistrationFailure& pfe) {
1846 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;
1854 if (!new_routes.empty()) {
1855 add_routes (new_routes, true, true, true);
1858 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1859 PluginPtr plugin = instrument->load (*this);
1860 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1861 (*r)->add_processor (p, PreFader);
1871 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1873 boost::shared_ptr<Route> midi_track (wmt.lock());
1879 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1881 if (change.after.n_audio() <= change.before.n_audio()) {
1885 /* new audio ports: make sure the audio goes somewhere useful,
1886 unless the user has no-auto-connect selected.
1888 The existing ChanCounts don't matter for this call as they are only
1889 to do with matching input and output indices, and we are only changing
1895 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1899 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1900 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1901 * @param output_start As \a input_start, but for outputs.
1904 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1905 bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1907 if (!IO::connecting_legal) {
1911 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1917 /* If both inputs and outputs are auto-connected to physical ports,
1918 use the max of input and output offsets to ensure auto-connected
1919 port numbers always match up (e.g. the first audio input and the
1920 first audio output of the route will have the same physical
1921 port number). Otherwise just use the lowest input or output
1925 DEBUG_TRACE (DEBUG::Graph,
1926 string_compose("Auto-connect: existing in = %1 out = %2\n",
1927 existing_inputs, existing_outputs));
1929 const bool in_out_physical =
1930 (Config->get_input_auto_connect() & AutoConnectPhysical)
1931 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1934 const ChanCount in_offset = in_out_physical
1935 ? ChanCount::max(existing_inputs, existing_outputs)
1938 const ChanCount out_offset = in_out_physical
1939 ? ChanCount::max(existing_inputs, existing_outputs)
1942 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1943 vector<string> physinputs;
1944 vector<string> physoutputs;
1946 _engine.get_physical_outputs (*t, physoutputs);
1947 _engine.get_physical_inputs (*t, physinputs);
1949 if (!physinputs.empty() && connect_inputs) {
1950 uint32_t nphysical_in = physinputs.size();
1952 DEBUG_TRACE (DEBUG::Graph,
1953 string_compose("There are %1 physical inputs of type %2\n",
1956 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1959 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1960 DEBUG_TRACE (DEBUG::Graph,
1961 string_compose("Get index %1 + %2 % %3 = %4\n",
1962 in_offset.get(*t), i, nphysical_in,
1963 (in_offset.get(*t) + i) % nphysical_in));
1964 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1967 DEBUG_TRACE (DEBUG::Graph,
1968 string_compose("Connect route %1 IN to %2\n",
1969 route->name(), port));
1971 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1975 ChanCount one_added (*t, 1);
1976 existing_inputs += one_added;
1980 if (!physoutputs.empty()) {
1981 uint32_t nphysical_out = physoutputs.size();
1982 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1985 if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
1986 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1987 } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
1988 /* master bus is audio only */
1989 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1990 port = _master_out->input()->ports().port(*t,
1991 i % _master_out->input()->n_ports().get(*t))->name();
1995 DEBUG_TRACE (DEBUG::Graph,
1996 string_compose("Connect route %1 OUT to %2\n",
1997 route->name(), port));
1999 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2003 ChanCount one_added (*t, 1);
2004 existing_outputs += one_added;
2010 /** Caller must not hold process lock
2011 * @param name_template string to use for the start of the name, or "" to use "Audio".
2013 list< boost::shared_ptr<AudioTrack> >
2014 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2015 uint32_t how_many, string name_template)
2017 char track_name[32];
2018 uint32_t track_id = 0;
2020 RouteList new_routes;
2021 list<boost::shared_ptr<AudioTrack> > ret;
2023 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
2026 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2027 error << "cannot find name for new audio track" << endmsg;
2031 boost::shared_ptr<AudioTrack> track;
2034 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2036 if (track->init ()) {
2040 track->use_new_diskstream();
2042 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2043 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2046 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2048 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2049 error << string_compose (
2050 _("cannot configure %1 in/%2 out configuration for new audio track"),
2051 input_channels, output_channels)
2056 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2057 error << string_compose (
2058 _("cannot configure %1 in/%2 out configuration for new audio track"),
2059 input_channels, output_channels)
2066 route_group->add (track);
2069 track->non_realtime_input_change();
2071 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2072 if (Config->get_remote_model() == UserOrdered) {
2073 track->set_remote_control_id (next_control_id());
2076 new_routes.push_back (track);
2077 ret.push_back (track);
2080 catch (failed_constructor &err) {
2081 error << _("Session: could not create new audio track.") << endmsg;
2085 catch (AudioEngine::PortRegistrationFailure& pfe) {
2087 error << pfe.what() << endmsg;
2095 if (!new_routes.empty()) {
2096 add_routes (new_routes, true, true, true);
2102 /** Caller must not hold process lock.
2103 * @param name_template string to use for the start of the name, or "" to use "Bus".
2106 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2109 uint32_t bus_id = 0;
2113 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2116 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2117 error << "cannot find name for new audio bus" << endmsg;
2122 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2128 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2129 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2132 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2134 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2135 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2136 input_channels, output_channels)
2142 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2143 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2144 input_channels, output_channels)
2151 route_group->add (bus);
2153 if (Config->get_remote_model() == UserOrdered) {
2154 bus->set_remote_control_id (next_control_id());
2157 bus->add_internal_return ();
2159 ret.push_back (bus);
2165 catch (failed_constructor &err) {
2166 error << _("Session: could not create new audio route.") << endmsg;
2170 catch (AudioEngine::PortRegistrationFailure& pfe) {
2171 error << pfe.what() << endmsg;
2181 add_routes (ret, false, true, true); // autoconnect outputs only
2189 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2192 uint32_t control_id;
2194 uint32_t number = 0;
2195 const uint32_t being_added = how_many;
2197 if (!tree.read (template_path.c_str())) {
2201 XMLNode* node = tree.root();
2203 IO::disable_connecting ();
2205 control_id = next_control_id ();
2209 XMLNode node_copy (*node);
2211 /* Remove IDs of everything so that new ones are used */
2212 node_copy.remove_property_recursively (X_("id"));
2217 if (!name_base.empty()) {
2219 /* if we're adding more than one routes, force
2220 * all the names of the new routes to be
2221 * numbered, via the final parameter.
2224 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2225 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2231 string const route_name = node_copy.property(X_("name"))->value ();
2233 /* generate a new name by adding a number to the end of the template name */
2234 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2235 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2240 /* set this name in the XML description that we are about to use */
2241 Route::set_name_in_state (node_copy, name);
2243 /* trim bitslots from listen sends so that new ones are used */
2244 XMLNodeList children = node_copy.children ();
2245 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2246 if ((*i)->name() == X_("Processor")) {
2247 XMLProperty* role = (*i)->property (X_("role"));
2248 if (role && role->value() == X_("Listen")) {
2249 (*i)->remove_property (X_("bitslot"));
2254 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2257 error << _("Session: cannot create track/bus from template description") << endmsg;
2261 if (boost::dynamic_pointer_cast<Track>(route)) {
2262 /* force input/output change signals so that the new diskstream
2263 picks up the configuration of the route. During session
2264 loading this normally happens in a different way.
2267 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2269 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2270 change.after = route->input()->n_ports();
2271 route->input()->changed (change, this);
2272 change.after = route->output()->n_ports();
2273 route->output()->changed (change, this);
2276 route->set_remote_control_id (control_id);
2279 ret.push_back (route);
2282 catch (failed_constructor &err) {
2283 error << _("Session: could not create new route from template") << endmsg;
2287 catch (AudioEngine::PortRegistrationFailure& pfe) {
2288 error << pfe.what() << endmsg;
2297 add_routes (ret, true, true, true);
2298 IO::enable_connecting ();
2305 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2308 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2309 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2312 error << _("Adding new tracks/busses failed") << endmsg;
2317 update_latency (true);
2318 update_latency (false);
2323 save_state (_current_snapshot_name);
2326 RouteAdded (new_routes); /* EMIT SIGNAL */
2330 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2332 ChanCount existing_inputs;
2333 ChanCount existing_outputs;
2334 uint32_t order = next_control_id();
2336 count_existing_track_channels (existing_inputs, existing_outputs);
2339 RCUWriter<RouteList> writer (routes);
2340 boost::shared_ptr<RouteList> r = writer.get_copy ();
2341 r->insert (r->end(), new_routes.begin(), new_routes.end());
2343 /* if there is no control out and we're not in the middle of loading,
2344 resort the graph here. if there is a control out, we will resort
2345 toward the end of this method. if we are in the middle of loading,
2346 we will resort when done.
2349 if (!_monitor_out && IO::connecting_legal) {
2350 resort_routes_using (r);
2354 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2356 boost::weak_ptr<Route> wpr (*x);
2357 boost::shared_ptr<Route> r (*x);
2359 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2360 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2361 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2362 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2363 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2364 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2366 if (r->is_master()) {
2370 if (r->is_monitor()) {
2374 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2376 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2377 track_playlist_changed (boost::weak_ptr<Track> (tr));
2378 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2380 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2382 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2383 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2388 if (input_auto_connect || output_auto_connect) {
2389 auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2392 /* order keys are a GUI responsibility but we need to set up
2393 reasonable defaults because they also affect the remote control
2394 ID in most situations.
2397 if (!r->has_order_key (EditorSort)) {
2398 if (r->is_auditioner()) {
2399 /* use an arbitrarily high value */
2400 r->set_order_key (EditorSort, UINT_MAX);
2401 r->set_order_key (MixerSort, UINT_MAX);
2403 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2404 r->set_order_key (EditorSort, order);
2405 r->set_order_key (MixerSort, order);
2413 if (_monitor_out && IO::connecting_legal) {
2414 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2416 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2417 if ((*x)->is_monitor()) {
2419 } else if ((*x)->is_master()) {
2422 (*x)->enable_monitor_send ();
2429 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2431 boost::shared_ptr<RouteList> r = routes.reader ();
2432 boost::shared_ptr<Send> s;
2434 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2435 if ((s = (*i)->internal_send_for (dest)) != 0) {
2436 s->amp()->gain_control()->set_value (0.0);
2442 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2444 boost::shared_ptr<RouteList> r = routes.reader ();
2445 boost::shared_ptr<Send> s;
2447 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2448 if ((s = (*i)->internal_send_for (dest)) != 0) {
2449 s->amp()->gain_control()->set_value (1.0);
2455 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2457 boost::shared_ptr<RouteList> r = routes.reader ();
2458 boost::shared_ptr<Send> s;
2460 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2461 if ((s = (*i)->internal_send_for (dest)) != 0) {
2462 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2467 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2469 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2471 boost::shared_ptr<RouteList> r = routes.reader ();
2472 boost::shared_ptr<RouteList> t (new RouteList);
2474 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2475 /* no MIDI sends because there are no MIDI busses yet */
2476 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2481 add_internal_sends (dest, p, t);
2485 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2487 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2488 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2493 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2495 add_internal_send (dest, sender->before_processor_for_index (index), sender);
2499 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2501 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2505 if (!dest->internal_return()) {
2506 dest->add_internal_return ();
2509 sender->add_aux_send (dest, before);
2515 Session::remove_route (boost::shared_ptr<Route> route)
2517 if (route == _master_out) {
2521 route->set_solo (false, this);
2524 RCUWriter<RouteList> writer (routes);
2525 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2529 /* deleting the master out seems like a dumb
2530 idea, but its more of a UI policy issue
2534 if (route == _master_out) {
2535 _master_out = boost::shared_ptr<Route> ();
2538 if (route == _monitor_out) {
2539 _monitor_out.reset ();
2542 /* writer goes out of scope, forces route list update */
2545 update_route_solo_state ();
2547 // We need to disconnect the route's inputs and outputs
2549 route->input()->disconnect (0);
2550 route->output()->disconnect (0);
2552 /* if the route had internal sends sending to it, remove them */
2553 if (route->internal_return()) {
2555 boost::shared_ptr<RouteList> r = routes.reader ();
2556 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2557 boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2559 (*i)->remove_processor (s);
2564 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2565 if (mt && mt->step_editing()) {
2566 if (_step_editors > 0) {
2571 update_latency_compensation ();
2574 /* Re-sort routes to remove the graph's current references to the one that is
2575 * going away, then flush old references out of the graph.
2579 if (_process_graph) {
2580 _process_graph->clear_other_chain ();
2583 /* get rid of it from the dead wood collection in the route list manager */
2585 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2589 /* try to cause everyone to drop their references */
2591 route->drop_references ();
2593 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2595 /* save the new state of the world */
2597 if (save_state (_current_snapshot_name)) {
2598 save_history (_current_snapshot_name);
2603 Session::route_mute_changed (void* /*src*/)
2609 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2611 boost::shared_ptr<Route> route = wpr.lock();
2613 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2617 if (route->listening_via_monitor ()) {
2619 if (Config->get_exclusive_solo()) {
2620 /* new listen: disable all other listen */
2621 boost::shared_ptr<RouteList> r = routes.reader ();
2622 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2623 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
2626 (*i)->set_listen (false, this);
2632 } else if (_listen_cnt > 0) {
2637 update_route_solo_state ();
2640 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2642 boost::shared_ptr<Route> route = wpr.lock ();
2645 /* should not happen */
2646 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2650 bool send_changed = false;
2652 if (route->solo_isolated()) {
2653 if (_solo_isolated_cnt == 0) {
2654 send_changed = true;
2656 _solo_isolated_cnt++;
2657 } else if (_solo_isolated_cnt > 0) {
2658 _solo_isolated_cnt--;
2659 if (_solo_isolated_cnt == 0) {
2660 send_changed = true;
2665 IsolatedChanged (); /* EMIT SIGNAL */
2670 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2672 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2674 if (!self_solo_change) {
2675 // session doesn't care about changes to soloed-by-others
2679 if (solo_update_disabled) {
2681 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2685 boost::shared_ptr<Route> route = wpr.lock ();
2688 boost::shared_ptr<RouteList> r = routes.reader ();
2691 if (route->self_soloed()) {
2697 RouteGroup* rg = route->route_group ();
2698 bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2700 if (delta == 1 && Config->get_exclusive_solo()) {
2702 /* new solo: disable all other solos, but not the group if its solo-enabled */
2704 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2705 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2706 (leave_group_alone && ((*i)->route_group() == rg))) {
2709 (*i)->set_solo (false, this);
2713 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2715 solo_update_disabled = true;
2717 RouteList uninvolved;
2719 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2721 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2722 bool via_sends_only;
2723 bool in_signal_flow;
2725 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2726 (leave_group_alone && ((*i)->route_group() == rg))) {
2730 in_signal_flow = false;
2732 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2734 if ((*i)->feeds (route, &via_sends_only)) {
2735 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2736 if (!via_sends_only) {
2737 if (!route->soloed_by_others_upstream()) {
2738 (*i)->mod_solo_by_others_downstream (delta);
2741 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2743 in_signal_flow = true;
2745 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2748 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2750 if (route->feeds (*i, &via_sends_only)) {
2751 /* propagate solo upstream only if routing other than
2752 sends is involved, but do consider the other route
2753 (*i) to be part of the signal flow even if only
2756 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2760 route->soloed_by_others_downstream(),
2761 route->soloed_by_others_upstream()));
2762 if (!via_sends_only) {
2763 if (!route->soloed_by_others_downstream()) {
2764 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2765 (*i)->mod_solo_by_others_upstream (delta);
2767 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2770 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2772 in_signal_flow = true;
2774 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2777 if (!in_signal_flow) {
2778 uninvolved.push_back (*i);
2782 solo_update_disabled = false;
2783 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2785 update_route_solo_state (r);
2787 /* now notify that the mute state of the routes not involved in the signal
2788 pathway of the just-solo-changed route may have altered.
2791 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2792 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2793 (*i)->mute_changed (this);
2796 SoloChanged (); /* EMIT SIGNAL */
2801 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2803 /* now figure out if anything that matters is soloed (or is "listening")*/
2805 bool something_soloed = false;
2806 uint32_t listeners = 0;
2807 uint32_t isolated = 0;
2810 r = routes.reader();
2813 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2814 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
2815 something_soloed = true;
2818 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
2819 if (Config->get_solo_control_is_listen_control()) {
2822 (*i)->set_listen (false, this);
2826 if ((*i)->solo_isolated()) {
2831 if (something_soloed != _non_soloed_outs_muted) {
2832 _non_soloed_outs_muted = something_soloed;
2833 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2836 _listen_cnt = listeners;
2838 if (isolated != _solo_isolated_cnt) {
2839 _solo_isolated_cnt = isolated;
2840 IsolatedChanged (); /* EMIT SIGNAL */
2843 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2844 something_soloed, listeners, isolated));
2847 boost::shared_ptr<RouteList>
2848 Session::get_routes_with_internal_returns() const
2850 boost::shared_ptr<RouteList> r = routes.reader ();
2851 boost::shared_ptr<RouteList> rl (new RouteList);
2853 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2854 if ((*i)->internal_return ()) {
2862 Session::io_name_is_legal (const std::string& name)
2864 boost::shared_ptr<RouteList> r = routes.reader ();
2866 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2867 if ((*i)->name() == name) {
2871 if ((*i)->has_io_processor_named (name)) {
2880 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2883 vector<string> connections;
2885 /* if we are passed only a single route and we're not told to turn
2886 * others off, then just do the simple thing.
2889 if (flip_others == false && rl->size() == 1) {
2890 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2892 mt->set_input_active (onoff);
2897 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2899 PortSet& ps ((*rt)->input()->ports());
2901 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2902 p->get_connections (connections);
2905 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2906 routes_using_input_from (*s, rl2);
2909 /* scan all relevant routes to see if others are on or off */
2911 bool others_are_already_on = false;
2913 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2915 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2921 if ((*r) != (*rt)) {
2922 if (mt->input_active()) {
2923 others_are_already_on = true;
2926 /* this one needs changing */
2927 mt->set_input_active (onoff);
2933 /* globally reverse other routes */
2935 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2936 if ((*r) != (*rt)) {
2937 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2939 mt->set_input_active (!others_are_already_on);
2948 Session::routes_using_input_from (const string& str, RouteList& rl)
2950 boost::shared_ptr<RouteList> r = routes.reader();
2952 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2953 if ((*i)->input()->connected_to (str)) {
2959 boost::shared_ptr<Route>
2960 Session::route_by_name (string name)
2962 boost::shared_ptr<RouteList> r = routes.reader ();
2964 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2965 if ((*i)->name() == name) {
2970 return boost::shared_ptr<Route> ((Route*) 0);
2973 boost::shared_ptr<Route>
2974 Session::route_by_id (PBD::ID id)
2976 boost::shared_ptr<RouteList> r = routes.reader ();
2978 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2979 if ((*i)->id() == id) {
2984 return boost::shared_ptr<Route> ((Route*) 0);
2987 boost::shared_ptr<Track>
2988 Session::track_by_diskstream_id (PBD::ID id)
2990 boost::shared_ptr<RouteList> r = routes.reader ();
2992 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2993 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
2994 if (t && t->using_diskstream_id (id)) {
2999 return boost::shared_ptr<Track> ();
3002 boost::shared_ptr<Route>
3003 Session::route_by_remote_id (uint32_t id)
3005 boost::shared_ptr<RouteList> r = routes.reader ();
3007 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3008 if ((*i)->remote_control_id() == id) {
3013 return boost::shared_ptr<Route> ((Route*) 0);
3017 Session::playlist_region_added (boost::weak_ptr<Region> w)
3019 boost::shared_ptr<Region> r = w.lock ();
3024 /* These are the operations that are currently in progress... */
3025 list<GQuark> curr = _current_trans_quarks;
3028 /* ...and these are the operations during which we want to update
3029 the session range location markers.
3032 ops.push_back (Operations::capture);
3033 ops.push_back (Operations::paste);
3034 ops.push_back (Operations::duplicate_region);
3035 ops.push_back (Operations::insert_file);
3036 ops.push_back (Operations::insert_region);
3037 ops.push_back (Operations::drag_region_brush);
3038 ops.push_back (Operations::region_drag);
3039 ops.push_back (Operations::selection_grab);
3040 ops.push_back (Operations::region_fill);
3041 ops.push_back (Operations::fill_selection);
3042 ops.push_back (Operations::create_region);
3043 ops.push_back (Operations::region_copy);
3044 ops.push_back (Operations::fixed_time_region_copy);
3047 /* See if any of the current operations match the ones that we want */
3049 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3051 /* If so, update the session range markers */
3053 maybe_update_session_range (r->position (), r->last_frame ());
3057 /** Update the session range markers if a is before the current start or
3058 * b is after the current end.
3061 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3063 if (_state_of_the_state & Loading) {
3067 if (_session_range_location == 0) {
3069 add_session_range_location (a, b);
3073 if (a < _session_range_location->start()) {
3074 _session_range_location->set_start (a);
3077 if (b > _session_range_location->end()) {
3078 _session_range_location->set_end (b);
3084 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3086 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3087 maybe_update_session_range (i->to, i->to + i->length);
3092 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3094 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3095 maybe_update_session_range (i->from, i->to);
3099 /* Region management */
3101 boost::shared_ptr<Region>
3102 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3104 const RegionFactory::RegionMap& regions (RegionFactory::regions());
3105 RegionFactory::RegionMap::const_iterator i;
3106 boost::shared_ptr<Region> region;
3108 Glib::Threads::Mutex::Lock lm (region_lock);
3110 for (i = regions.begin(); i != regions.end(); ++i) {
3114 if (region->whole_file()) {
3116 if (child->source_equivalent (region)) {
3122 return boost::shared_ptr<Region> ();
3126 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3128 set<boost::shared_ptr<Region> > relevant_regions;
3130 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3131 RegionFactory::get_regions_using_source (*s, relevant_regions);
3134 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3135 set<boost::shared_ptr<Region> >::iterator tmp;
3140 playlists->destroy_region (*r);
3141 RegionFactory::map_remove (*r);
3143 (*r)->drop_sources ();
3144 (*r)->drop_references ();
3146 relevant_regions.erase (r);
3151 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3154 Glib::Threads::Mutex::Lock ls (source_lock);
3155 /* remove from the main source list */
3156 sources.erase ((*s)->id());
3159 (*s)->mark_for_remove ();
3160 (*s)->drop_references ();
3169 Session::remove_last_capture ()
3171 list<boost::shared_ptr<Source> > srcs;
3173 boost::shared_ptr<RouteList> rl = routes.reader ();
3174 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3175 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3180 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3183 srcs.insert (srcs.end(), l.begin(), l.end());
3188 destroy_sources (srcs);
3190 save_state (_current_snapshot_name);
3195 /* Source Management */
3198 Session::add_source (boost::shared_ptr<Source> source)
3200 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3201 pair<SourceMap::iterator,bool> result;
3203 entry.first = source->id();
3204 entry.second = source;
3207 Glib::Threads::Mutex::Lock lm (source_lock);
3208 result = sources.insert (entry);
3211 if (result.second) {
3213 /* yay, new source */
3215 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3218 if (!fs->within_session()) {
3219 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3225 boost::shared_ptr<AudioFileSource> afs;
3227 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3228 if (Config->get_auto_analyse_audio()) {
3229 Analyser::queue_source_for_analysis (source, false);
3233 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3238 Session::remove_source (boost::weak_ptr<Source> src)
3240 if (_state_of_the_state & Deletion) {
3244 SourceMap::iterator i;
3245 boost::shared_ptr<Source> source = src.lock();
3252 Glib::Threads::Mutex::Lock lm (source_lock);
3254 if ((i = sources.find (source->id())) != sources.end()) {
3259 if (!(_state_of_the_state & InCleanup)) {
3261 /* save state so we don't end up with a session file
3262 referring to non-existent sources.
3265 save_state (_current_snapshot_name);
3269 boost::shared_ptr<Source>
3270 Session::source_by_id (const PBD::ID& id)
3272 Glib::Threads::Mutex::Lock lm (source_lock);
3273 SourceMap::iterator i;
3274 boost::shared_ptr<Source> source;
3276 if ((i = sources.find (id)) != sources.end()) {
3283 boost::shared_ptr<Source>
3284 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3286 Glib::Threads::Mutex::Lock lm (source_lock);
3288 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3289 boost::shared_ptr<AudioFileSource> afs
3290 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3292 if (afs && afs->path() == path && chn == afs->channel()) {
3296 return boost::shared_ptr<Source>();
3300 Session::count_sources_by_origin (const string& path)
3303 Glib::Threads::Mutex::Lock lm (source_lock);
3305 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3306 boost::shared_ptr<FileSource> fs
3307 = boost::dynamic_pointer_cast<FileSource>(i->second);
3309 if (fs && fs->origin() == path) {
3319 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3322 string old_basename = PBD::basename_nosuffix (oldname);
3323 string new_legalized = legalize_for_path (newname);
3325 /* note: we know (or assume) the old path is already valid */
3329 /* destructive file sources have a name of the form:
3331 /path/to/Tnnnn-NAME(%[LR])?.wav
3333 the task here is to replace NAME with the new name.
3338 string::size_type dash;
3340 dir = Glib::path_get_dirname (path);
3341 path = Glib::path_get_basename (path);
3343 /* '-' is not a legal character for the NAME part of the path */
3345 if ((dash = path.find_last_of ('-')) == string::npos) {
3349 prefix = path.substr (0, dash);
3353 path += new_legalized;
3354 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3355 path = Glib::build_filename (dir, path);
3359 /* non-destructive file sources have a name of the form:
3361 /path/to/NAME-nnnnn(%[LR])?.ext
3363 the task here is to replace NAME with the new name.
3368 string::size_type dash;
3369 string::size_type postfix;
3371 dir = Glib::path_get_dirname (path);
3372 path = Glib::path_get_basename (path);
3374 /* '-' is not a legal character for the NAME part of the path */
3376 if ((dash = path.find_last_of ('-')) == string::npos) {
3380 suffix = path.substr (dash+1);
3382 // Suffix is now everything after the dash. Now we need to eliminate
3383 // the nnnnn part, which is done by either finding a '%' or a '.'
3385 postfix = suffix.find_last_of ("%");
3386 if (postfix == string::npos) {
3387 postfix = suffix.find_last_of ('.');
3390 if (postfix != string::npos) {
3391 suffix = suffix.substr (postfix);
3393 error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3397 const uint32_t limit = 10000;
3398 char buf[PATH_MAX+1];
3400 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3402 snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3404 if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3405 path = Glib::build_filename (dir, buf);
3413 fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3422 /** Return the full path (in some session directory) for a new within-session source.
3423 * \a name must be a session-unique name that does not contain slashes
3424 * (e.g. as returned by new_*_source_name)
3427 Session::new_source_path_from_name (DataType type, const string& name)
3429 assert(name.find("/") == string::npos);
3431 SessionDirectory sdir(get_best_session_directory_for_new_source());
3434 if (type == DataType::AUDIO) {
3435 p = sdir.sound_path();
3436 } else if (type == DataType::MIDI) {
3437 p = sdir.midi_path();
3439 error << "Unknown source type, unable to create file path" << endmsg;
3443 return Glib::build_filename (p, name);
3447 Session::peak_path (string base) const
3449 return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3452 /** Return a unique name based on \a base for a new internal audio source */
3454 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3457 char buf[PATH_MAX+1];
3458 const uint32_t limit = 10000;
3460 string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3463 legalized = legalize_for_path (base);
3465 // Find a "version" of the base name that doesn't exist in any of the possible directories.
3466 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3468 vector<space_and_path>::iterator i;
3469 uint32_t existing = 0;
3471 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3476 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3477 cnt, legalized.c_str(), ext.c_str());
3478 } else if (nchan == 2) {
3480 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3481 cnt, legalized.c_str(), ext.c_str());
3483 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3484 cnt, legalized.c_str(), ext.c_str());
3486 } else if (nchan < 26) {
3487 snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3488 cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3490 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3491 cnt, legalized.c_str(), ext.c_str());
3497 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3498 } else if (nchan == 2) {
3500 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3502 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3504 } else if (nchan < 26) {
3505 snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3507 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3511 SessionDirectory sdir((*i).path);
3513 string spath = sdir.sound_path();
3515 /* note that we search *without* the extension so that
3516 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3517 in the event that this new name is required for
3518 a file format change.
3521 if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3527 if (existing == 0) {
3532 error << string_compose(
3533 _("There are already %1 recordings for %2, which I consider too many."),
3534 limit, base) << endmsg;
3536 throw failed_constructor();
3540 return Glib::path_get_basename (buf);
3543 /** Create a new within-session audio source */
3544 boost::shared_ptr<AudioFileSource>
3545 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3547 const string name = new_audio_source_name (n, n_chans, chan, destructive);
3548 const string path = new_source_path_from_name(DataType::AUDIO, name);
3550 return boost::dynamic_pointer_cast<AudioFileSource> (
3551 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3554 /** Return a unique name based on \a base for a new internal MIDI source */
3556 Session::new_midi_source_name (const string& base)
3559 char buf[PATH_MAX+1];
3560 const uint32_t limit = 10000;
3564 legalized = legalize_for_path (base);
3566 // Find a "version" of the file name that doesn't exist in any of the possible directories.
3567 for (cnt = 1; cnt <= limit; ++cnt) {
3569 vector<space_and_path>::iterator i;
3570 uint32_t existing = 0;
3572 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3574 SessionDirectory sdir((*i).path);
3576 std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3578 snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3580 if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3585 if (existing == 0) {
3590 error << string_compose(
3591 _("There are already %1 recordings for %2, which I consider too many."),
3592 limit, base) << endmsg;
3594 throw failed_constructor();
3598 return Glib::path_get_basename(buf);
3602 /** Create a new within-session MIDI source */
3603 boost::shared_ptr<MidiSource>
3604 Session::create_midi_source_for_session (Track* track, string const & n)
3606 /* try to use the existing write source for the track, to keep numbering sane
3610 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3614 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3617 assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3618 return boost::dynamic_pointer_cast<MidiSource> (l.front());
3622 const string name = new_midi_source_name (n);
3623 const string path = new_source_path_from_name (DataType::MIDI, name);
3625 return boost::dynamic_pointer_cast<SMFSource> (
3626 SourceFactory::createWritable (
3627 DataType::MIDI, *this, path, false, frame_rate()));
3632 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3634 if (playlist->hidden()) {
3638 playlists->add (playlist);
3641 playlist->release();
3648 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3650 if (_state_of_the_state & Deletion) {
3654 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3660 playlists->remove (playlist);
3666 Session::set_audition (boost::shared_ptr<Region> r)
3668 pending_audition_region = r;
3669 add_post_transport_work (PostTransportAudition);
3670 _butler->schedule_transport_work ();
3674 Session::audition_playlist ()
3676 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3677 ev->region.reset ();
3682 Session::non_realtime_set_audition ()
3684 assert (pending_audition_region);
3685 auditioner->audition_region (pending_audition_region);
3686 pending_audition_region.reset ();
3687 AuditionActive (true); /* EMIT SIGNAL */
3691 Session::audition_region (boost::shared_ptr<Region> r)
3693 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3699 Session::cancel_audition ()
3701 if (auditioner->auditioning()) {
3702 auditioner->cancel_audition ();
3703 AuditionActive (false); /* EMIT SIGNAL */
3708 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3710 if (a->is_monitor()) {
3713 if (b->is_monitor()) {
3716 return a->order_key (MixerSort) < b->order_key (MixerSort);
3720 Session::is_auditioning () const
3722 /* can be called before we have an auditioner object */
3724 return auditioner->auditioning();
3731 Session::graph_reordered ()
3733 /* don't do this stuff if we are setting up connections
3734 from a set_state() call or creating new tracks. Ditto for deletion.
3737 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3741 /* every track/bus asked for this to be handled but it was deferred because
3742 we were connecting. do it now.
3745 request_input_change_handling ();
3749 /* force all diskstreams to update their capture offset values to
3750 reflect any changes in latencies within the graph.
3753 boost::shared_ptr<RouteList> rl = routes.reader ();
3754 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3755 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3757 tr->set_capture_offset ();
3762 /** @return Number of frames that there is disk space available to write,
3765 boost::optional<framecnt_t>
3766 Session::available_capture_duration ()
3768 Glib::Threads::Mutex::Lock lm (space_lock);
3770 if (_total_free_4k_blocks_uncertain) {
3771 return boost::optional<framecnt_t> ();
3774 float sample_bytes_on_disk = 4.0; // keep gcc happy
3776 switch (config.get_native_file_data_format()) {
3778 sample_bytes_on_disk = 4.0;
3782 sample_bytes_on_disk = 3.0;
3786 sample_bytes_on_disk = 2.0;
3790 /* impossible, but keep some gcc versions happy */
3791 fatal << string_compose (_("programming error: %1"),
3792 X_("illegal native file data format"))
3797 double scale = 4096.0 / sample_bytes_on_disk;
3799 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3800 return max_framecnt;
3803 return (framecnt_t) floor (_total_free_4k_blocks * scale);
3807 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3810 RCUWriter<BundleList> writer (_bundles);
3811 boost::shared_ptr<BundleList> b = writer.get_copy ();
3812 b->push_back (bundle);
3815 BundleAdded (bundle); /* EMIT SIGNAL */
3821 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3823 bool removed = false;
3826 RCUWriter<BundleList> writer (_bundles);
3827 boost::shared_ptr<BundleList> b = writer.get_copy ();
3828 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3830 if (i != b->end()) {
3837 BundleRemoved (bundle); /* EMIT SIGNAL */
3843 boost::shared_ptr<Bundle>
3844 Session::bundle_by_name (string name) const
3846 boost::shared_ptr<BundleList> b = _bundles.reader ();
3848 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3849 if ((*i)->name() == name) {
3854 return boost::shared_ptr<Bundle> ();
3858 Session::tempo_map_changed (const PropertyChange&)
3862 playlists->update_after_tempo_map_change ();
3864 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3870 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3872 for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3873 (*i)->recompute_frames_from_bbt ();
3877 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3878 * the given count with the current block size.
3881 Session::ensure_buffers (ChanCount howmany)
3883 BufferManager::ensure_buffers (howmany);
3887 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3889 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3890 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3895 Session::next_insert_id ()
3897 /* this doesn't really loop forever. just think about it */
3900 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3901 if (!insert_bitset[n]) {
3902 insert_bitset[n] = true;
3908 /* none available, so resize and try again */
3910 insert_bitset.resize (insert_bitset.size() + 16, false);
3915 Session::next_send_id ()
3917 /* this doesn't really loop forever. just think about it */
3920 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3921 if (!send_bitset[n]) {
3922 send_bitset[n] = true;
3928 /* none available, so resize and try again */
3930 send_bitset.resize (send_bitset.size() + 16, false);
3935 Session::next_aux_send_id ()
3937 /* this doesn't really loop forever. just think about it */
3940 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3941 if (!aux_send_bitset[n]) {
3942 aux_send_bitset[n] = true;
3948 /* none available, so resize and try again */
3950 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3955 Session::next_return_id ()
3957 /* this doesn't really loop forever. just think about it */
3960 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3961 if (!return_bitset[n]) {
3962 return_bitset[n] = true;
3968 /* none available, so resize and try again */
3970 return_bitset.resize (return_bitset.size() + 16, false);
3975 Session::mark_send_id (uint32_t id)
3977 if (id >= send_bitset.size()) {
3978 send_bitset.resize (id+16, false);
3980 if (send_bitset[id]) {
3981 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3983 send_bitset[id] = true;
3987 Session::mark_aux_send_id (uint32_t id)
3989 if (id >= aux_send_bitset.size()) {
3990 aux_send_bitset.resize (id+16, false);
3992 if (aux_send_bitset[id]) {
3993 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3995 aux_send_bitset[id] = true;
3999 Session::mark_return_id (uint32_t id)
4001 if (id >= return_bitset.size()) {
4002 return_bitset.resize (id+16, false);
4004 if (return_bitset[id]) {
4005 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4007 return_bitset[id] = true;
4011 Session::mark_insert_id (uint32_t id)
4013 if (id >= insert_bitset.size()) {
4014 insert_bitset.resize (id+16, false);
4016 if (insert_bitset[id]) {
4017 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4019 insert_bitset[id] = true;
4023 Session::unmark_send_id (uint32_t id)
4025 if (id < send_bitset.size()) {
4026 send_bitset[id] = false;
4031 Session::unmark_aux_send_id (uint32_t id)
4033 if (id < aux_send_bitset.size()) {
4034 aux_send_bitset[id] = false;
4039 Session::unmark_return_id (uint32_t id)
4041 if (id < return_bitset.size()) {
4042 return_bitset[id] = false;
4047 Session::unmark_insert_id (uint32_t id)
4049 if (id < insert_bitset.size()) {
4050 insert_bitset[id] = false;
4055 Session::reset_native_file_format ()
4057 boost::shared_ptr<RouteList> rl = routes.reader ();
4058 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4059 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4061 /* don't save state as we do this, there's no point
4064 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4065 tr->reset_write_sources (false);
4066 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4072 Session::route_name_unique (string n) const
4074 boost::shared_ptr<RouteList> r = routes.reader ();
4076 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4077 if ((*i)->name() == n) {
4086 Session::route_name_internal (string n) const
4088 if (auditioner && auditioner->name() == n) {
4092 if (_click_io && _click_io->name() == n) {
4100 Session::freeze_all (InterThreadInfo& itt)
4102 boost::shared_ptr<RouteList> r = routes.reader ();
4104 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4106 boost::shared_ptr<Track> t;
4108 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4109 /* XXX this is wrong because itt.progress will keep returning to zero at the start
4119 boost::shared_ptr<Region>
4120 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
4121 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4122 InterThreadInfo& itt,
4123 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4126 boost::shared_ptr<Region> result;
4127 boost::shared_ptr<Playlist> playlist;
4128 boost::shared_ptr<AudioFileSource> fsource;
4130 char buf[PATH_MAX+1];
4131 ChanCount diskstream_channels (track.n_channels());
4132 framepos_t position;
4133 framecnt_t this_chunk;
4136 SessionDirectory sdir(get_best_session_directory_for_new_source ());
4137 const string sound_dir = sdir.sound_path();
4138 framepos_t len = end - start;
4139 bool need_block_size_reset = false;
4141 ChanCount const max_proc = track.max_processor_streams ();
4144 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4145 end, start) << endmsg;
4149 const framecnt_t chunk_size = (256 * 1024)/4;
4151 // block all process callback handling
4153 block_processing ();
4155 /* call tree *MUST* hold route_lock */
4157 if ((playlist = track.playlist()) == 0) {
4161 ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4163 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
4165 for (x = 0; x < 99999; ++x) {
4166 snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 "%s", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1, ext.c_str());
4167 if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
4173 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4178 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4179 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
4182 catch (failed_constructor& err) {
4183 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4187 srcs.push_back (fsource);
4190 /* tell redirects that care that we are about to use a much larger
4191 * blocksize. this will flush all plugins too, so that they are ready
4192 * to be used for this process.
4195 need_block_size_reset = true;
4196 track.set_block_size (chunk_size);
4201 /* create a set of reasonably-sized buffers */
4202 buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4203 buffers.set_count (max_proc);
4205 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4206 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4208 afs->prepare_for_peakfile_writes ();
4211 while (to_do && !itt.cancel) {
4213 this_chunk = min (to_do, chunk_size);
4215 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4220 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4221 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4224 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4230 start += this_chunk;
4231 to_do -= this_chunk;
4233 itt.progress = (float) (1.0 - ((double) to_do / len));
4242 xnow = localtime (&now);
4244 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4245 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4248 afs->update_header (position, *xnow, now);
4249 afs->flush_header ();
4253 /* construct a region to represent the bounced material */
4257 plist.add (Properties::start, 0);
4258 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4259 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4261 result = RegionFactory::create (srcs, plist);
4267 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4268 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4271 afs->mark_for_remove ();
4274 (*src)->drop_references ();
4278 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4279 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4282 afs->done_with_peakfile_writes ();
4287 if (need_block_size_reset) {
4288 track.set_block_size (get_block_size());
4291 unblock_processing ();
4297 Session::gain_automation_buffer() const
4299 return ProcessThread::gain_automation_buffer ();
4303 Session::send_gain_automation_buffer() const
4305 return ProcessThread::send_gain_automation_buffer ();
4309 Session::pan_automation_buffer() const
4311 return ProcessThread::pan_automation_buffer ();
4315 Session::get_silent_buffers (ChanCount count)
4317 return ProcessThread::get_silent_buffers (count);
4321 Session::get_scratch_buffers (ChanCount count, bool silence)
4323 return ProcessThread::get_scratch_buffers (count, silence);
4327 Session::get_route_buffers (ChanCount count, bool silence)
4329 return ProcessThread::get_route_buffers (count, silence);
4334 Session::get_mix_buffers (ChanCount count)
4336 return ProcessThread::get_mix_buffers (count);
4340 Session::ntracks () const
4343 boost::shared_ptr<RouteList> r = routes.reader ();
4345 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4346 if (boost::dynamic_pointer_cast<Track> (*i)) {
4355 Session::nbusses () const
4358 boost::shared_ptr<RouteList> r = routes.reader ();
4360 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4361 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4370 Session::add_automation_list(AutomationList *al)
4372 automation_lists[al->id()] = al;
4375 /** @return true if there is at least one record-enabled track, otherwise false */
4377 Session::have_rec_enabled_track () const
4379 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4382 /** Update the state of our rec-enabled tracks flag */
4384 Session::update_have_rec_enabled_track ()
4386 boost::shared_ptr<RouteList> rl = routes.reader ();
4387 RouteList::iterator i = rl->begin();
4388 while (i != rl->end ()) {
4390 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4391 if (tr && tr->record_enabled ()) {
4398 int const old = g_atomic_int_get (&_have_rec_enabled_track);
4400 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4402 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4403 RecordStateChanged (); /* EMIT SIGNAL */
4408 Session::listen_position_changed ()
4410 boost::shared_ptr<RouteList> r = routes.reader ();
4412 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4413 (*i)->listen_position_changed ();
4418 Session::solo_control_mode_changed ()
4420 /* cancel all solo or all listen when solo control mode changes */
4423 set_solo (get_routes(), false);
4424 } else if (listening()) {
4425 set_listen (get_routes(), false);
4429 /** Called when a property of one of our route groups changes */
4431 Session::route_group_property_changed (RouteGroup* rg)
4433 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4436 /** Called when a route is added to one of our route groups */
4438 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4440 RouteAddedToRouteGroup (rg, r);
4443 /** Called when a route is removed from one of our route groups */
4445 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4447 RouteRemovedFromRouteGroup (rg, r);
4450 boost::shared_ptr<RouteList>
4451 Session::get_routes_with_regions_at (framepos_t const p) const
4453 boost::shared_ptr<RouteList> r = routes.reader ();
4454 boost::shared_ptr<RouteList> rl (new RouteList);
4456 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4457 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4462 boost::shared_ptr<Playlist> pl = tr->playlist ();
4467 if (pl->has_region_at (p)) {
4476 Session::goto_end ()
4478 if (_session_range_location) {
4479 request_locate (_session_range_location->end(), false);
4481 request_locate (0, false);
4486 Session::goto_start ()
4488 if (_session_range_location) {
4489 request_locate (_session_range_location->start(), false);
4491 request_locate (0, false);
4496 Session::current_start_frame () const
4498 return _session_range_location ? _session_range_location->start() : 0;
4502 Session::current_end_frame () const
4504 return _session_range_location ? _session_range_location->end() : 0;
4508 Session::add_session_range_location (framepos_t start, framepos_t end)
4510 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4511 _locations->add (_session_range_location);
4515 Session::step_edit_status_change (bool yn)
4521 send = (_step_editors == 0);
4526 send = (_step_editors == 1);
4529 if (_step_editors > 0) {
4535 StepEditStatusChange (val);
4541 Session::start_time_changed (framepos_t old)
4543 /* Update the auto loop range to match the session range
4544 (unless the auto loop range has been changed by the user)
4547 Location* s = _locations->session_range_location ();
4552 Location* l = _locations->auto_loop_location ();
4554 if (l && l->start() == old) {
4555 l->set_start (s->start(), true);
4560 Session::end_time_changed (framepos_t old)
4562 /* Update the auto loop range to match the session range
4563 (unless the auto loop range has been changed by the user)
4566 Location* s = _locations->session_range_location ();
4571 Location* l = _locations->auto_loop_location ();
4573 if (l && l->end() == old) {
4574 l->set_end (s->end(), true);
4578 std::vector<std::string>
4579 Session::source_search_path (DataType type) const
4583 if (session_dirs.size() == 1) {
4585 case DataType::AUDIO:
4586 sp.push_back (_session_dir->sound_path());
4588 case DataType::MIDI:
4589 sp.push_back (_session_dir->midi_path());
4593 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4594 SessionDirectory sdir (i->path);
4596 case DataType::AUDIO:
4597 sp.push_back (sdir.sound_path());
4599 case DataType::MIDI:
4600 sp.push_back (sdir.midi_path());
4606 if (type == DataType::AUDIO) {
4607 const string sound_path_2X = _session_dir->sound_path_2X();
4608 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4609 if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
4610 sp.push_back (sound_path_2X);
4615 // now check the explicit (possibly user-specified) search path
4618 case DataType::AUDIO:
4619 sp += Searchpath(config.get_audio_search_path ());
4621 case DataType::MIDI:
4622 sp += Searchpath(config.get_midi_search_path ());
4630 Session::ensure_search_path_includes (const string& path, DataType type)
4639 case DataType::AUDIO:
4640 sp += Searchpath(config.get_audio_search_path ());
4642 case DataType::MIDI:
4643 sp += Searchpath (config.get_midi_search_path ());
4647 for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
4648 /* No need to add this new directory if it has the same inode as
4649 an existing one; checking inode rather than name prevents duplicated
4650 directories when we are using symlinks.
4652 On Windows, I think we could just do if (*i == path) here.
4654 if (PBD::equivalent_paths (*i, path)) {
4662 case DataType::AUDIO:
4663 config.set_audio_search_path (sp.to_string());
4665 case DataType::MIDI:
4666 config.set_midi_search_path (sp.to_string());
4671 boost::shared_ptr<Speakers>
4672 Session::get_speakers()
4678 Session::unknown_processors () const
4682 boost::shared_ptr<RouteList> r = routes.reader ();
4683 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4684 list<string> t = (*i)->unknown_processors ();
4685 copy (t.begin(), t.end(), back_inserter (p));
4695 Session::update_latency (bool playback)
4697 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4699 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4703 boost::shared_ptr<RouteList> r = routes.reader ();
4704 framecnt_t max_latency = 0;
4707 /* reverse the list so that we work backwards from the last route to run to the first */
4708 RouteList* rl = routes.reader().get();
4709 r.reset (new RouteList (*rl));
4710 reverse (r->begin(), r->end());
4713 /* compute actual latency values for the given direction and store them all in per-port
4714 structures. this will also publish the same values (to JACK) so that computation of latency
4715 for routes can consistently use public latency values.
4718 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4719 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4722 /* because we latency compensate playback, our published playback latencies should
4723 be the same for all output ports - all material played back by ardour has
4724 the same latency, whether its caused by plugins or by latency compensation. since
4725 these may differ from the values computed above, reset all playback port latencies
4729 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4731 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4732 (*i)->set_public_port_latencies (max_latency, playback);
4737 post_playback_latency ();
4741 post_capture_latency ();
4744 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4748 Session::post_playback_latency ()
4750 set_worst_playback_latency ();
4752 boost::shared_ptr<RouteList> r = routes.reader ();
4754 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4755 if (!(*i)->is_auditioner() && ((*i)->active())) {
4756 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4760 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4761 (*i)->set_latency_compensation (_worst_track_latency);
4766 Session::post_capture_latency ()
4768 set_worst_capture_latency ();
4770 /* reflect any changes in capture latencies into capture offsets
4773 boost::shared_ptr<RouteList> rl = routes.reader();
4774 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4775 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4777 tr->set_capture_offset ();
4783 Session::initialize_latencies ()
4786 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4787 update_latency (false);
4788 update_latency (true);
4791 set_worst_io_latencies ();
4795 Session::set_worst_io_latencies ()
4797 set_worst_playback_latency ();
4798 set_worst_capture_latency ();
4802 Session::set_worst_playback_latency ()
4804 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4808 _worst_output_latency = 0;
4810 if (!_engine.connected()) {
4814 boost::shared_ptr<RouteList> r = routes.reader ();
4816 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4817 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4820 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4824 Session::set_worst_capture_latency ()
4826 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4830 _worst_input_latency = 0;
4832 if (!_engine.connected()) {
4836 boost::shared_ptr<RouteList> r = routes.reader ();
4838 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4839 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4842 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4846 Session::update_latency_compensation (bool force_whole_graph)
4848 bool some_track_latency_changed = false;
4850 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4854 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4856 _worst_track_latency = 0;
4858 boost::shared_ptr<RouteList> r = routes.reader ();
4860 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4861 if (!(*i)->is_auditioner() && ((*i)->active())) {
4863 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4864 some_track_latency_changed = true;
4866 _worst_track_latency = max (tl, _worst_track_latency);
4870 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4871 (some_track_latency_changed ? "yes" : "no")));
4873 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4875 if (some_track_latency_changed || force_whole_graph) {
4876 _engine.update_latencies ();
4880 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4881 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4885 tr->set_capture_offset ();
4890 Session::session_name_is_legal (const string& path)
4892 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4894 for (int i = 0; illegal_chars[i]; ++i) {
4895 if (path.find (illegal_chars[i]) != string::npos) {
4896 return illegal_chars[i];
4904 Session::next_control_id () const
4908 /* the monitor bus remote ID is in a different
4909 * "namespace" than regular routes. its existence doesn't
4910 * affect normal (low) numbered routes.
4917 return nroutes() - subtract;
4921 Session::notify_remote_id_change ()
4923 if (deletion_in_progress()) {
4927 switch (Config->get_remote_model()) {
4930 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4938 Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
4940 if (deletion_in_progress()) {
4944 /* tell everyone that something has happened to the sort keys
4945 and let them sync up with the change(s)
4946 this will give objects that manage the sort order keys the
4947 opportunity to keep them in sync if they wish to.
4950 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
4952 Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
4954 DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
4958 Session::operation_in_progress (GQuark op) const
4960 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4963 boost::shared_ptr<Port>
4964 Session::ltc_input_port () const
4966 return _ltc_input->nth (0);
4969 boost::shared_ptr<Port>
4970 Session::ltc_output_port () const
4972 return _ltc_output->nth (0);
4976 Session::reconnect_ltc_input ()
4980 string src = Config->get_ltc_source_port();
4982 _ltc_input->disconnect (this);
4984 if (src != _("None") && !src.empty()) {
4985 _ltc_input->nth (0)->connect (src);
4991 Session::reconnect_ltc_output ()
4996 string src = Config->get_ltc_sink_port();
4998 _ltc_output->disconnect (this);
5000 if (src != _("None") && !src.empty()) {
5001 _ltc_output->nth (0)->connect (src);