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/strsplit.h"
48 #include "pbd/unwind.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)
261 , ignore_route_processor_changes (false)
267 pre_engine_init (fullpath);
270 if (ensure_engine (sr)) {
272 throw failed_constructor ();
275 if (create (mix_template, bus_profile)) {
277 throw failed_constructor ();
280 /* if a mix template was provided, then ::create() will
281 * have copied it into the session and we need to load it
282 * so that we have the state ready for ::set_state()
283 * after the engine is started.
285 * Note that we do NOT try to get the sample rate from
286 * the template at this time, though doing so would
287 * be easy if we decided this was an appropriate part
291 if (!mix_template.empty() && load_state (_current_snapshot_name)) {
292 throw failed_constructor ();
297 if (load_state (_current_snapshot_name)) {
298 throw failed_constructor ();
301 /* try to get sample rate from XML state so that we
302 * can influence the SR if we set up the audio
307 const XMLProperty* prop;
308 if ((prop = state_tree->root()->property (X_("sample-rate"))) != 0) {
309 sr = atoi (prop->value());
313 if (ensure_engine (sr)) {
315 throw failed_constructor ();
319 if (post_engine_init ()) {
321 throw failed_constructor ();
324 store_recent_sessions (_name, _path);
326 bool was_dirty = dirty();
328 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
330 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
331 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
334 DirtyChanged (); /* EMIT SIGNAL */
337 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
338 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
342 /* hook us up to the engine since we are now completely constructed */
344 BootMessage (_("Connect to engine"));
346 _engine.set_session (this);
347 _engine.reset_timebase ();
349 BootMessage (_("Session loading complete"));
362 Session::ensure_engine (uint32_t desired_sample_rate)
364 if (_engine.current_backend() == 0) {
365 /* backend is unknown ... */
366 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
367 if (r.get_value_or (-1) != 0) {
370 } else if (_engine.setup_required()) {
371 /* backend is known, but setup is needed */
372 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
373 if (r.get_value_or (-1) != 0) {
376 } else if (!_engine.running()) {
377 if (_engine.start()) {
382 /* at this point the engine should be running
385 if (!_engine.running()) {
389 return immediately_post_engine ();
394 Session::immediately_post_engine ()
396 /* Do various initializations that should take place directly after we
397 * know that the engine is running, but before we either create a
398 * session or set state for an existing one.
401 if (how_many_dsp_threads () > 1) {
402 /* For now, only create the graph if we are using >1 DSP threads, as
403 it is a bit slower than the old code with 1 thread.
405 _process_graph.reset (new Graph (*this));
408 /* every time we reconnect, recompute worst case output latencies */
410 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
412 if (synced_to_engine()) {
413 _engine.transport_stop ();
416 if (config.get_jack_time_master()) {
417 _engine.transport_locate (_transport_frame);
421 BootMessage (_("Set up LTC"));
423 BootMessage (_("Set up Click"));
425 BootMessage (_("Set up standard connections"));
429 catch (failed_constructor& err) {
439 vector<void*> debug_pointers;
441 /* if we got to here, leaving pending capture state around
445 remove_pending_capture_state ();
447 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
449 /* disconnect from any and all signals that we are connected to */
453 _engine.remove_session ();
455 /* deregister all ports - there will be no process or any other
456 * callbacks from the engine any more.
459 Port::PortDrop (); /* EMIT SIGNAL */
463 /* clear history so that no references to objects are held any more */
467 /* clear state tree so that no references to objects are held any more */
471 /* reset dynamic state version back to default */
473 Stateful::loading_state_version = 0;
475 _butler->drop_references ();
479 delete midi_control_ui;
480 delete _all_route_group;
482 if (click_data != default_click) {
483 delete [] click_data;
486 if (click_emphasis_data != default_click_emphasis) {
487 delete [] click_emphasis_data;
492 /* clear out any pending dead wood from RCU managed objects */
497 AudioDiskstream::free_working_buffers();
499 /* tell everyone who is still standing that we're about to die */
502 /* tell everyone to drop references and delete objects as we go */
504 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
505 RegionFactory::delete_all_regions ();
507 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
509 /* reset these three references to special routes before we do the usual route delete thing */
512 _master_out.reset ();
513 _monitor_out.reset ();
516 RCUWriter<RouteList> writer (routes);
517 boost::shared_ptr<RouteList> r = writer.get_copy ();
519 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
520 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
521 (*i)->drop_references ();
525 /* writer goes out of scope and updates master */
529 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
530 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
531 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
532 i->second->drop_references ();
537 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
538 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
543 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
546 delete _mmc; _mmc = 0;
547 delete _midi_ports; _midi_ports = 0;
548 delete _locations; _locations = 0;
550 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
552 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
553 boost_debug_list_ptrs ();
558 Session::setup_ltc ()
562 _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
563 _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
565 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
566 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
569 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
570 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
572 reconnect_ltc_input ();
575 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
576 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
579 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
580 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
582 reconnect_ltc_output ();
585 /* fix up names of LTC ports because we don't want the normal
586 * IO style of NAME/TYPE-{in,out}N
589 _ltc_input->nth (0)->set_name (X_("LTC-in"));
590 _ltc_output->nth (0)->set_name (X_("LTC-out"));
594 Session::setup_click ()
597 _click_io.reset (new ClickIO (*this, X_("Click")));
598 _click_gain.reset (new Amp (*this));
599 _click_gain->activate ();
601 setup_click_state (state_tree->root());
603 setup_click_state (0);
608 Session::setup_click_state (const XMLNode* node)
610 const XMLNode* child = 0;
612 if (node && (child = find_named_node (*node, "Click")) != 0) {
614 /* existing state for Click */
617 if (Stateful::loading_state_version < 3000) {
618 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
620 const XMLNodeList& children (child->children());
621 XMLNodeList::const_iterator i = children.begin();
622 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
624 if (i != children.end()) {
625 c = _click_gain->set_state (**i, Stateful::loading_state_version);
631 _clicking = Config->get_clicking ();
635 error << _("could not setup Click I/O") << endmsg;
642 /* default state for Click: dual-mono to first 2 physical outputs */
645 _engine.get_physical_outputs (DataType::AUDIO, outs);
647 for (uint32_t physport = 0; physport < 2; ++physport) {
648 if (outs.size() > physport) {
649 if (_click_io->add_port (outs[physport], this)) {
650 // relax, even though its an error
655 if (_click_io->n_ports () > ChanCount::ZERO) {
656 _clicking = Config->get_clicking ();
662 Session::setup_bundles ()
664 vector<string> inputs[DataType::num_types];
665 vector<string> outputs[DataType::num_types];
666 for (uint32_t i = 0; i < DataType::num_types; ++i) {
667 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
668 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
671 /* Create a set of Bundle objects that map
672 to the physical I/O currently available. We create both
673 mono and stereo bundles, so that the common cases of mono
674 and stereo tracks get bundles to put in their mixer strip
675 in / out menus. There may be a nicer way of achieving that;
676 it doesn't really scale that well to higher channel counts
679 /* mono output bundles */
681 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
683 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
685 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
686 c->add_channel (_("mono"), DataType::AUDIO);
687 c->set_port (0, outputs[DataType::AUDIO][np]);
692 /* stereo output bundles */
694 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
695 if (np + 1 < outputs[DataType::AUDIO].size()) {
697 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
698 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
699 c->add_channel (_("L"), DataType::AUDIO);
700 c->set_port (0, outputs[DataType::AUDIO][np]);
701 c->add_channel (_("R"), DataType::AUDIO);
702 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
708 /* mono input bundles */
710 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
712 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
714 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
715 c->add_channel (_("mono"), DataType::AUDIO);
716 c->set_port (0, inputs[DataType::AUDIO][np]);
721 /* stereo input bundles */
723 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
724 if (np + 1 < inputs[DataType::AUDIO].size()) {
726 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
728 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
729 c->add_channel (_("L"), DataType::AUDIO);
730 c->set_port (0, inputs[DataType::AUDIO][np]);
731 c->add_channel (_("R"), DataType::AUDIO);
732 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
738 /* MIDI input bundles */
740 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
741 string n = inputs[DataType::MIDI][np];
742 boost::erase_first (n, X_("alsa_pcm:"));
744 boost::shared_ptr<Bundle> c (new Bundle (n, false));
745 c->add_channel ("", DataType::MIDI);
746 c->set_port (0, inputs[DataType::MIDI][np]);
750 /* MIDI output bundles */
752 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
753 string n = outputs[DataType::MIDI][np];
754 boost::erase_first (n, X_("alsa_pcm:"));
756 boost::shared_ptr<Bundle> c (new Bundle (n, true));
757 c->add_channel ("", DataType::MIDI);
758 c->set_port (0, outputs[DataType::MIDI][np]);
765 Session::auto_connect_master_bus ()
767 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
771 /* if requested auto-connect the outputs to the first N physical ports.
774 uint32_t limit = _master_out->n_outputs().n_total();
775 vector<string> outputs[DataType::num_types];
777 for (uint32_t i = 0; i < DataType::num_types; ++i) {
778 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
781 for (uint32_t n = 0; n < limit; ++n) {
782 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
784 if (outputs[p->type()].size() > n) {
785 connect_to = outputs[p->type()][n];
788 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
789 if (_master_out->output()->connect (p, connect_to, this)) {
790 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
799 Session::remove_monitor_section ()
805 /* force reversion to Solo-In-Place */
806 Config->set_solo_control_is_listen_control (false);
809 /* Hold process lock while doing this so that we don't hear bits and
810 * pieces of audio as we work on each route.
813 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
815 /* Connect tracks to monitor section. Note that in an
816 existing session, the internal sends will already exist, but we want the
817 routes to notice that they connect to the control out specifically.
821 boost::shared_ptr<RouteList> r = routes.reader ();
822 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
824 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
826 if ((*x)->is_monitor()) {
828 } else if ((*x)->is_master()) {
831 (*x)->remove_aux_or_listen (_monitor_out);
836 remove_route (_monitor_out);
837 auto_connect_master_bus ();
841 Session::add_monitor_section ()
845 if (_monitor_out || !_master_out) {
849 boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
855 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
856 // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
859 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
860 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
861 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
865 add_routes (rl, false, false, false);
867 assert (_monitor_out);
869 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
870 are undefined, at best.
873 uint32_t limit = _monitor_out->n_inputs().n_audio();
877 /* connect the inputs to the master bus outputs. this
878 * represents a separate data feed from the internal sends from
879 * each route. as of jan 2011, it allows the monitor section to
880 * conditionally ignore either the internal sends or the normal
881 * input feed, but we should really find a better way to do
885 _master_out->output()->disconnect (this);
887 for (uint32_t n = 0; n < limit; ++n) {
888 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
889 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
892 string connect_to = o->name();
893 if (_monitor_out->input()->connect (p, connect_to, this)) {
894 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
902 /* if monitor section is not connected, connect it to physical outs
905 if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
907 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
909 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
912 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
914 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
915 Config->get_monitor_bus_preferred_bundle())
921 /* Monitor bus is audio only */
923 vector<string> outputs[DataType::num_types];
925 for (uint32_t i = 0; i < DataType::num_types; ++i) {
926 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
929 uint32_t mod = outputs[DataType::AUDIO].size();
930 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
934 for (uint32_t n = 0; n < limit; ++n) {
936 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
938 if (outputs[DataType::AUDIO].size() > (n % mod)) {
939 connect_to = outputs[DataType::AUDIO][n % mod];
942 if (!connect_to.empty()) {
943 if (_monitor_out->output()->connect (p, connect_to, this)) {
944 error << string_compose (
945 _("cannot connect control output %1 to %2"),
956 /* Hold process lock while doing this so that we don't hear bits and
957 * pieces of audio as we work on each route.
960 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
962 /* Connect tracks to monitor section. Note that in an
963 existing session, the internal sends will already exist, but we want the
964 routes to notice that they connect to the control out specifically.
968 boost::shared_ptr<RouteList> rls = routes.reader ();
970 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
972 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
974 if ((*x)->is_monitor()) {
976 } else if ((*x)->is_master()) {
979 (*x)->enable_monitor_send ();
985 Session::hookup_io ()
987 /* stop graph reordering notifications from
988 causing resorts, etc.
991 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
995 /* we delay creating the auditioner till now because
996 it makes its own connections to ports.
1000 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1002 throw failed_constructor ();
1004 a->use_new_diskstream ();
1008 catch (failed_constructor& err) {
1009 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1013 /* load bundles, which we may have postponed earlier on */
1014 if (_bundle_xml_node) {
1015 load_bundles (*_bundle_xml_node);
1016 delete _bundle_xml_node;
1019 /* Tell all IO objects to connect themselves together */
1021 IO::enable_connecting ();
1023 /* Now tell all "floating" ports to connect to whatever
1024 they should be connected to.
1027 AudioEngine::instance()->reconnect_ports ();
1029 /* Anyone who cares about input state, wake up and do something */
1031 IOConnectionsComplete (); /* EMIT SIGNAL */
1033 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1035 /* now handle the whole enchilada as if it was one
1036 graph reorder event.
1041 /* update the full solo state, which can't be
1042 correctly determined on a per-route basis, but
1043 needs the global overview that only the session
1047 update_route_solo_state ();
1051 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1053 boost::shared_ptr<Track> track = wp.lock ();
1058 boost::shared_ptr<Playlist> playlist;
1060 if ((playlist = track->playlist()) != 0) {
1061 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1062 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1063 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1068 Session::record_enabling_legal () const
1070 /* this used to be in here, but survey says.... we don't need to restrict it */
1071 // if (record_status() == Recording) {
1075 if (Config->get_all_safe()) {
1082 Session::set_track_monitor_input_status (bool yn)
1084 boost::shared_ptr<RouteList> rl = routes.reader ();
1085 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1086 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1087 if (tr && tr->record_enabled ()) {
1088 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1089 tr->request_input_monitoring (yn);
1095 Session::auto_punch_start_changed (Location* location)
1097 replace_event (SessionEvent::PunchIn, location->start());
1099 if (get_record_enabled() && config.get_punch_in()) {
1100 /* capture start has been changed, so save new pending state */
1101 save_state ("", true);
1106 Session::auto_punch_end_changed (Location* location)
1108 framepos_t when_to_stop = location->end();
1109 // when_to_stop += _worst_output_latency + _worst_input_latency;
1110 replace_event (SessionEvent::PunchOut, when_to_stop);
1114 Session::auto_punch_changed (Location* location)
1116 framepos_t when_to_stop = location->end();
1118 replace_event (SessionEvent::PunchIn, location->start());
1119 //when_to_stop += _worst_output_latency + _worst_input_latency;
1120 replace_event (SessionEvent::PunchOut, when_to_stop);
1123 /** @param loc A loop location.
1124 * @param pos Filled in with the start time of the required fade-out (in session frames).
1125 * @param length Filled in with the length of the required fade-out.
1128 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1130 pos = max (loc->start(), loc->end() - 64);
1131 length = loc->end() - pos;
1135 Session::auto_loop_changed (Location* location)
1137 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1140 auto_loop_declick_range (location, dcp, dcl);
1141 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1143 if (transport_rolling() && play_loop) {
1146 // if (_transport_frame > location->end()) {
1148 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1149 // relocate to beginning of loop
1150 clear_events (SessionEvent::LocateRoll);
1152 request_locate (location->start(), true);
1155 else if (Config->get_seamless_loop() && !loop_changing) {
1157 // schedule a locate-roll to refill the diskstreams at the
1158 // previous loop end
1159 loop_changing = true;
1161 if (location->end() > last_loopend) {
1162 clear_events (SessionEvent::LocateRoll);
1163 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1170 last_loopend = location->end();
1174 Session::set_auto_punch_location (Location* location)
1178 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1179 punch_connections.drop_connections();
1180 existing->set_auto_punch (false, this);
1181 remove_event (existing->start(), SessionEvent::PunchIn);
1182 clear_events (SessionEvent::PunchOut);
1183 auto_punch_location_changed (0);
1188 if (location == 0) {
1192 if (location->end() <= location->start()) {
1193 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1197 punch_connections.drop_connections ();
1199 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
1200 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
1201 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
1203 location->set_auto_punch (true, this);
1205 auto_punch_changed (location);
1207 auto_punch_location_changed (location);
1211 Session::set_auto_loop_location (Location* location)
1215 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1216 loop_connections.drop_connections ();
1217 existing->set_auto_loop (false, this);
1218 remove_event (existing->end(), SessionEvent::AutoLoop);
1221 auto_loop_declick_range (existing, dcp, dcl);
1222 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1223 auto_loop_location_changed (0);
1228 if (location == 0) {
1232 if (location->end() <= location->start()) {
1233 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1237 last_loopend = location->end();
1239 loop_connections.drop_connections ();
1241 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1242 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1243 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1245 location->set_auto_loop (true, this);
1247 /* take care of our stuff first */
1249 auto_loop_changed (location);
1251 /* now tell everyone else */
1253 auto_loop_location_changed (location);
1257 Session::locations_added (Location *)
1263 Session::locations_changed ()
1265 _locations->apply (*this, &Session::handle_locations_changed);
1269 Session::handle_locations_changed (Locations::LocationList& locations)
1271 Locations::LocationList::iterator i;
1273 bool set_loop = false;
1274 bool set_punch = false;
1276 for (i = locations.begin(); i != locations.end(); ++i) {
1280 if (location->is_auto_punch()) {
1281 set_auto_punch_location (location);
1284 if (location->is_auto_loop()) {
1285 set_auto_loop_location (location);
1289 if (location->is_session_range()) {
1290 _session_range_location = location;
1295 set_auto_loop_location (0);
1298 set_auto_punch_location (0);
1305 Session::enable_record ()
1307 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1308 /* no recording at anything except normal speed */
1313 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1315 if (rs == Recording) {
1319 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1321 _last_record_location = _transport_frame;
1322 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1324 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1325 set_track_monitor_input_status (true);
1328 RecordStateChanged ();
1335 Session::disable_record (bool rt_context, bool force)
1339 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1341 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1342 g_atomic_int_set (&_record_status, Disabled);
1343 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1345 if (rs == Recording) {
1346 g_atomic_int_set (&_record_status, Enabled);
1350 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1351 set_track_monitor_input_status (false);
1354 RecordStateChanged (); /* emit signal */
1357 remove_pending_capture_state ();
1363 Session::step_back_from_record ()
1365 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1367 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1368 set_track_monitor_input_status (false);
1371 RecordStateChanged (); /* emit signal */
1376 Session::maybe_enable_record ()
1378 if (_step_editors > 0) {
1382 g_atomic_int_set (&_record_status, Enabled);
1384 /* This function is currently called from somewhere other than an RT thread.
1385 This save_state() call therefore doesn't impact anything. Doing it here
1386 means that we save pending state of which sources the next record will use,
1387 which gives us some chance of recovering from a crash during the record.
1390 save_state ("", true);
1392 if (_transport_speed) {
1393 if (!config.get_punch_in()) {
1397 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1398 RecordStateChanged (); /* EMIT SIGNAL */
1405 Session::audible_frame () const
1411 /* the first of these two possible settings for "offset"
1412 mean that the audible frame is stationary until
1413 audio emerges from the latency compensation
1416 the second means that the audible frame is stationary
1417 until audio would emerge from a physical port
1418 in the absence of any plugin latency compensation
1421 offset = worst_playback_latency ();
1423 if (offset > current_block_size) {
1424 offset -= current_block_size;
1426 /* XXX is this correct? if we have no external
1427 physical connections and everything is internal
1428 then surely this is zero? still, how
1429 likely is that anyway?
1431 offset = current_block_size;
1434 if (synced_to_engine()) {
1435 tf = _engine.transport_frame();
1437 tf = _transport_frame;
1442 if (!non_realtime_work_pending()) {
1446 /* Check to see if we have passed the first guaranteed
1447 audible frame past our last start position. if not,
1448 return that last start point because in terms
1449 of audible frames, we have not moved yet.
1451 `Start position' in this context means the time we last
1452 either started, located, or changed transport direction.
1455 if (_transport_speed > 0.0f) {
1457 if (!play_loop || !have_looped) {
1458 if (tf < _last_roll_or_reversal_location + offset) {
1459 return _last_roll_or_reversal_location;
1467 } else if (_transport_speed < 0.0f) {
1469 /* XXX wot? no backward looping? */
1471 if (tf > _last_roll_or_reversal_location - offset) {
1472 return _last_roll_or_reversal_location;
1484 Session::set_frame_rate (framecnt_t frames_per_second)
1486 /** \fn void Session::set_frame_size(framecnt_t)
1487 the AudioEngine object that calls this guarantees
1488 that it will not be called while we are also in
1489 ::process(). Its fine to do things that block
1493 _base_frame_rate = frames_per_second;
1494 _nominal_frame_rate = frames_per_second;
1500 // XXX we need some equivalent to this, somehow
1501 // SndFileSource::setup_standard_crossfades (frames_per_second);
1505 /* XXX need to reset/reinstantiate all LADSPA plugins */
1509 Session::set_block_size (pframes_t nframes)
1511 /* the AudioEngine guarantees
1512 that it will not be called while we are also in
1513 ::process(). It is therefore fine to do things that block
1518 current_block_size = nframes;
1522 boost::shared_ptr<RouteList> r = routes.reader ();
1524 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1525 (*i)->set_block_size (nframes);
1528 boost::shared_ptr<RouteList> rl = routes.reader ();
1529 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1530 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1532 tr->set_block_size (nframes);
1536 set_worst_io_latencies ();
1542 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1544 boost::shared_ptr<Route> r2;
1546 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1547 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1551 /* make a copy of the existing list of routes that feed r1 */
1553 Route::FedBy existing (r1->fed_by());
1555 /* for each route that feeds r1, recurse, marking it as feeding
1559 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1560 if (!(r2 = i->r.lock ())) {
1561 /* (*i) went away, ignore it */
1565 /* r2 is a route that feeds r1 which somehow feeds base. mark
1566 base as being fed by r2
1569 rbase->add_fed_by (r2, i->sends_only);
1573 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1577 if (r1->feeds (r2) && r2->feeds (r1)) {
1581 /* now recurse, so that we can mark base as being fed by
1582 all routes that feed r2
1585 trace_terminal (r2, rbase);
1592 Session::resort_routes ()
1594 /* don't do anything here with signals emitted
1595 by Routes during initial setup or while we
1596 are being destroyed.
1599 if (_state_of_the_state & (InitialConnecting | Deletion)) {
1604 RCUWriter<RouteList> writer (routes);
1605 boost::shared_ptr<RouteList> r = writer.get_copy ();
1606 resort_routes_using (r);
1607 /* writer goes out of scope and forces update */
1611 boost::shared_ptr<RouteList> rl = routes.reader ();
1612 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1613 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1615 const Route::FedBy& fb ((*i)->fed_by());
1617 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1618 boost::shared_ptr<Route> sf = f->r.lock();
1620 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1628 /** This is called whenever we need to rebuild the graph of how we will process
1630 * @param r List of routes, in any order.
1634 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1636 /* We are going to build a directed graph of our routes;
1637 this is where the edges of that graph are put.
1642 /* Go through all routes doing two things:
1644 * 1. Collect the edges of the route graph. Each of these edges
1645 * is a pair of routes, one of which directly feeds the other
1646 * either by a JACK connection or by an internal send.
1648 * 2. Begin the process of making routes aware of which other
1649 * routes directly or indirectly feed them. This information
1650 * is used by the solo code.
1653 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1655 /* Clear out the route's list of direct or indirect feeds */
1656 (*i)->clear_fed_by ();
1658 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1660 bool via_sends_only;
1662 /* See if this *j feeds *i according to the current state of the JACK
1663 connections and internal sends.
1665 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1666 /* add the edge to the graph (part #1) */
1667 edges.add (*j, *i, via_sends_only);
1668 /* tell the route (for part #2) */
1669 (*i)->add_fed_by (*j, via_sends_only);
1674 /* Attempt a topological sort of the route graph */
1675 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1677 if (sorted_routes) {
1678 /* We got a satisfactory topological sort, so there is no feedback;
1681 Note: the process graph rechain does not require a
1682 topologically-sorted list, but hey ho.
1684 if (_process_graph) {
1685 _process_graph->rechain (sorted_routes, edges);
1688 _current_route_graph = edges;
1690 /* Complete the building of the routes' lists of what directly
1691 or indirectly feeds them.
1693 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1694 trace_terminal (*i, *i);
1697 *r = *sorted_routes;
1700 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1701 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1702 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1703 (*i)->name(), (*i)->order_key ()));
1707 SuccessfulGraphSort (); /* EMIT SIGNAL */
1710 /* The topological sort failed, so we have a problem. Tell everyone
1711 and stick to the old graph; this will continue to be processed, so
1712 until the feedback is fixed, what is played back will not quite
1713 reflect what is actually connected. Note also that we do not
1714 do trace_terminal here, as it would fail due to an endless recursion,
1715 so the solo code will think that everything is still connected
1719 FeedbackDetected (); /* EMIT SIGNAL */
1724 /** Find a route name starting with \a base, maybe followed by the
1725 * lowest \a id. \a id will always be added if \a definitely_add_number
1726 * is true on entry; otherwise it will only be added if required
1727 * to make the name unique.
1729 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1730 * The available route name with the lowest ID will be used, and \a id
1731 * will be set to the ID.
1733 * \return false if a route name could not be found, and \a track_name
1734 * and \a id do not reflect a free route name.
1737 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1739 if (!definitely_add_number && route_by_name (base) == 0) {
1740 /* juse use the base */
1741 snprintf (name, name_len, "%s", base.c_str());
1746 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1748 if (route_by_name (name) == 0) {
1754 } while (id < (UINT_MAX-1));
1759 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1761 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1763 in = ChanCount::ZERO;
1764 out = ChanCount::ZERO;
1766 boost::shared_ptr<RouteList> r = routes.reader ();
1768 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1769 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1770 if (tr && !tr->is_auditioner()) {
1771 in += tr->n_inputs();
1772 out += tr->n_outputs();
1777 /** Caller must not hold process lock
1778 * @param name_template string to use for the start of the name, or "" to use "MIDI".
1779 * @param instrument plugin info for the instrument to insert pre-fader, if any
1781 list<boost::shared_ptr<MidiTrack> >
1782 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1783 TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1785 char track_name[32];
1786 uint32_t track_id = 0;
1788 RouteList new_routes;
1789 list<boost::shared_ptr<MidiTrack> > ret;
1791 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1794 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1795 error << "cannot find name for new midi track" << endmsg;
1799 boost::shared_ptr<MidiTrack> track;
1802 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1804 if (track->init ()) {
1808 track->use_new_diskstream();
1810 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1811 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1814 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1815 if (track->input()->ensure_io (input, false, this)) {
1816 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1820 if (track->output()->ensure_io (output, false, this)) {
1821 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1826 track->non_realtime_input_change();
1829 route_group->add (track);
1832 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1834 if (Config->get_remote_model() == UserOrdered) {
1835 track->set_remote_control_id (next_control_id());
1838 new_routes.push_back (track);
1839 ret.push_back (track);
1842 catch (failed_constructor &err) {
1843 error << _("Session: could not create new midi track.") << endmsg;
1847 catch (AudioEngine::PortRegistrationFailure& pfe) {
1849 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;
1857 if (!new_routes.empty()) {
1858 add_routes (new_routes, true, true, true);
1861 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1862 PluginPtr plugin = instrument->load (*this);
1863 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1864 (*r)->add_processor (p, PreFader);
1874 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1876 boost::shared_ptr<Route> midi_track (wmt.lock());
1882 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1884 if (change.after.n_audio() <= change.before.n_audio()) {
1888 /* new audio ports: make sure the audio goes somewhere useful,
1889 unless the user has no-auto-connect selected.
1891 The existing ChanCounts don't matter for this call as they are only
1892 to do with matching input and output indices, and we are only changing
1898 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1902 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1903 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1904 * @param output_start As \a input_start, but for outputs.
1907 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1908 bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1910 if (!IO::connecting_legal) {
1914 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1920 /* If both inputs and outputs are auto-connected to physical ports,
1921 use the max of input and output offsets to ensure auto-connected
1922 port numbers always match up (e.g. the first audio input and the
1923 first audio output of the route will have the same physical
1924 port number). Otherwise just use the lowest input or output
1928 DEBUG_TRACE (DEBUG::Graph,
1929 string_compose("Auto-connect: existing in = %1 out = %2\n",
1930 existing_inputs, existing_outputs));
1932 const bool in_out_physical =
1933 (Config->get_input_auto_connect() & AutoConnectPhysical)
1934 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1937 const ChanCount in_offset = in_out_physical
1938 ? ChanCount::max(existing_inputs, existing_outputs)
1941 const ChanCount out_offset = in_out_physical
1942 ? ChanCount::max(existing_inputs, existing_outputs)
1945 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1946 vector<string> physinputs;
1947 vector<string> physoutputs;
1949 _engine.get_physical_outputs (*t, physoutputs);
1950 _engine.get_physical_inputs (*t, physinputs);
1952 if (!physinputs.empty() && connect_inputs) {
1953 uint32_t nphysical_in = physinputs.size();
1955 DEBUG_TRACE (DEBUG::Graph,
1956 string_compose("There are %1 physical inputs of type %2\n",
1959 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1962 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1963 DEBUG_TRACE (DEBUG::Graph,
1964 string_compose("Get index %1 + %2 % %3 = %4\n",
1965 in_offset.get(*t), i, nphysical_in,
1966 (in_offset.get(*t) + i) % nphysical_in));
1967 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1970 DEBUG_TRACE (DEBUG::Graph,
1971 string_compose("Connect route %1 IN to %2\n",
1972 route->name(), port));
1974 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1978 ChanCount one_added (*t, 1);
1979 existing_inputs += one_added;
1983 if (!physoutputs.empty()) {
1984 uint32_t nphysical_out = physoutputs.size();
1985 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1988 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
1989 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1990 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
1991 /* master bus is audio only */
1992 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1993 port = _master_out->input()->ports().port(*t,
1994 i % _master_out->input()->n_ports().get(*t))->name();
1998 DEBUG_TRACE (DEBUG::Graph,
1999 string_compose("Connect route %1 OUT to %2\n",
2000 route->name(), port));
2002 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2006 ChanCount one_added (*t, 1);
2007 existing_outputs += one_added;
2013 /** Caller must not hold process lock
2014 * @param name_template string to use for the start of the name, or "" to use "Audio".
2016 list< boost::shared_ptr<AudioTrack> >
2017 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2018 uint32_t how_many, string name_template)
2020 char track_name[32];
2021 uint32_t track_id = 0;
2023 RouteList new_routes;
2024 list<boost::shared_ptr<AudioTrack> > ret;
2026 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
2029 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2030 error << "cannot find name for new audio track" << endmsg;
2034 boost::shared_ptr<AudioTrack> track;
2037 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2039 if (track->init ()) {
2043 track->use_new_diskstream();
2045 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2046 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2049 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2051 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2052 error << string_compose (
2053 _("cannot configure %1 in/%2 out configuration for new audio track"),
2054 input_channels, output_channels)
2059 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2060 error << string_compose (
2061 _("cannot configure %1 in/%2 out configuration for new audio track"),
2062 input_channels, output_channels)
2069 route_group->add (track);
2072 track->non_realtime_input_change();
2074 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2075 if (Config->get_remote_model() == UserOrdered) {
2076 track->set_remote_control_id (next_control_id());
2079 new_routes.push_back (track);
2080 ret.push_back (track);
2083 catch (failed_constructor &err) {
2084 error << _("Session: could not create new audio track.") << endmsg;
2088 catch (AudioEngine::PortRegistrationFailure& pfe) {
2090 error << pfe.what() << endmsg;
2098 if (!new_routes.empty()) {
2099 add_routes (new_routes, true, true, true);
2105 /** Caller must not hold process lock.
2106 * @param name_template string to use for the start of the name, or "" to use "Bus".
2109 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2112 uint32_t bus_id = 0;
2116 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2119 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2120 error << "cannot find name for new audio bus" << endmsg;
2125 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2131 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2132 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2135 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2137 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2138 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2139 input_channels, output_channels)
2145 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2146 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2147 input_channels, output_channels)
2154 route_group->add (bus);
2156 if (Config->get_remote_model() == UserOrdered) {
2157 bus->set_remote_control_id (next_control_id());
2160 bus->add_internal_return ();
2162 ret.push_back (bus);
2168 catch (failed_constructor &err) {
2169 error << _("Session: could not create new audio route.") << endmsg;
2173 catch (AudioEngine::PortRegistrationFailure& pfe) {
2174 error << pfe.what() << endmsg;
2184 add_routes (ret, false, true, true); // autoconnect outputs only
2192 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2195 uint32_t control_id;
2197 uint32_t number = 0;
2198 const uint32_t being_added = how_many;
2200 if (!tree.read (template_path.c_str())) {
2204 XMLNode* node = tree.root();
2206 IO::disable_connecting ();
2208 control_id = next_control_id ();
2212 XMLNode node_copy (*node);
2214 /* Remove IDs of everything so that new ones are used */
2215 node_copy.remove_property_recursively (X_("id"));
2220 if (!name_base.empty()) {
2222 /* if we're adding more than one routes, force
2223 * all the names of the new routes to be
2224 * numbered, via the final parameter.
2227 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2228 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2234 string const route_name = node_copy.property(X_("name"))->value ();
2236 /* generate a new name by adding a number to the end of the template name */
2237 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2238 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2243 /* set this name in the XML description that we are about to use */
2244 Route::set_name_in_state (node_copy, name);
2246 /* trim bitslots from listen sends so that new ones are used */
2247 XMLNodeList children = node_copy.children ();
2248 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2249 if ((*i)->name() == X_("Processor")) {
2250 XMLProperty* role = (*i)->property (X_("role"));
2251 if (role && role->value() == X_("Listen")) {
2252 (*i)->remove_property (X_("bitslot"));
2257 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2260 error << _("Session: cannot create track/bus from template description") << endmsg;
2264 if (boost::dynamic_pointer_cast<Track>(route)) {
2265 /* force input/output change signals so that the new diskstream
2266 picks up the configuration of the route. During session
2267 loading this normally happens in a different way.
2270 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2272 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2273 change.after = route->input()->n_ports();
2274 route->input()->changed (change, this);
2275 change.after = route->output()->n_ports();
2276 route->output()->changed (change, this);
2279 route->set_remote_control_id (control_id);
2282 ret.push_back (route);
2285 catch (failed_constructor &err) {
2286 error << _("Session: could not create new route from template") << endmsg;
2290 catch (AudioEngine::PortRegistrationFailure& pfe) {
2291 error << pfe.what() << endmsg;
2300 add_routes (ret, true, true, true);
2301 IO::enable_connecting ();
2308 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2311 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2312 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2315 error << _("Adding new tracks/busses failed") << endmsg;
2320 update_latency (true);
2321 update_latency (false);
2326 save_state (_current_snapshot_name);
2329 RouteAdded (new_routes); /* EMIT SIGNAL */
2333 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2335 ChanCount existing_inputs;
2336 ChanCount existing_outputs;
2337 uint32_t order = next_control_id();
2339 if (_order_hint != 0) {
2340 order = _order_hint;
2344 count_existing_track_channels (existing_inputs, existing_outputs);
2347 RCUWriter<RouteList> writer (routes);
2348 boost::shared_ptr<RouteList> r = writer.get_copy ();
2349 r->insert (r->end(), new_routes.begin(), new_routes.end());
2351 /* if there is no control out and we're not in the middle of loading,
2352 resort the graph here. if there is a control out, we will resort
2353 toward the end of this method. if we are in the middle of loading,
2354 we will resort when done.
2357 if (!_monitor_out && IO::connecting_legal) {
2358 resort_routes_using (r);
2362 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2364 boost::weak_ptr<Route> wpr (*x);
2365 boost::shared_ptr<Route> r (*x);
2367 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2368 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2369 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2370 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2371 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2372 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2374 if (r->is_master()) {
2378 if (r->is_monitor()) {
2382 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2384 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2385 track_playlist_changed (boost::weak_ptr<Track> (tr));
2386 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2388 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2390 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2391 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2396 if (input_auto_connect || output_auto_connect) {
2397 auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2400 /* order keys are a GUI responsibility but we need to set up
2401 reasonable defaults because they also affect the remote control
2402 ID in most situations.
2405 if (!r->has_order_key ()) {
2406 if (r->is_auditioner()) {
2407 /* use an arbitrarily high value */
2408 r->set_order_key (UINT_MAX);
2410 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2411 r->set_order_key (order);
2419 if (_monitor_out && IO::connecting_legal) {
2420 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2422 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2423 if ((*x)->is_monitor()) {
2425 } else if ((*x)->is_master()) {
2428 (*x)->enable_monitor_send ();
2435 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2437 boost::shared_ptr<RouteList> r = routes.reader ();
2438 boost::shared_ptr<Send> s;
2440 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2441 if ((s = (*i)->internal_send_for (dest)) != 0) {
2442 s->amp()->gain_control()->set_value (0.0);
2448 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2450 boost::shared_ptr<RouteList> r = routes.reader ();
2451 boost::shared_ptr<Send> s;
2453 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2454 if ((s = (*i)->internal_send_for (dest)) != 0) {
2455 s->amp()->gain_control()->set_value (1.0);
2461 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2463 boost::shared_ptr<RouteList> r = routes.reader ();
2464 boost::shared_ptr<Send> s;
2466 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2467 if ((s = (*i)->internal_send_for (dest)) != 0) {
2468 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2473 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2475 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2477 boost::shared_ptr<RouteList> r = routes.reader ();
2478 boost::shared_ptr<RouteList> t (new RouteList);
2480 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2481 /* no MIDI sends because there are no MIDI busses yet */
2482 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2487 add_internal_sends (dest, p, t);
2491 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2493 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2494 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2499 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2501 add_internal_send (dest, sender->before_processor_for_index (index), sender);
2505 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2507 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2511 if (!dest->internal_return()) {
2512 dest->add_internal_return ();
2515 sender->add_aux_send (dest, before);
2521 Session::remove_route (boost::shared_ptr<Route> route)
2523 if (route == _master_out) {
2527 route->set_solo (false, this);
2530 RCUWriter<RouteList> writer (routes);
2531 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2535 /* deleting the master out seems like a dumb
2536 idea, but its more of a UI policy issue
2540 if (route == _master_out) {
2541 _master_out = boost::shared_ptr<Route> ();
2544 if (route == _monitor_out) {
2545 _monitor_out.reset ();
2548 /* writer goes out of scope, forces route list update */
2551 update_route_solo_state ();
2553 // We need to disconnect the route's inputs and outputs
2555 route->input()->disconnect (0);
2556 route->output()->disconnect (0);
2558 /* if the route had internal sends sending to it, remove them */
2559 if (route->internal_return()) {
2561 boost::shared_ptr<RouteList> r = routes.reader ();
2562 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2563 boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2565 (*i)->remove_processor (s);
2570 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2571 if (mt && mt->step_editing()) {
2572 if (_step_editors > 0) {
2577 update_latency_compensation ();
2580 /* Re-sort routes to remove the graph's current references to the one that is
2581 * going away, then flush old references out of the graph.
2585 if (_process_graph) {
2586 _process_graph->clear_other_chain ();
2589 /* get rid of it from the dead wood collection in the route list manager */
2591 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2595 /* try to cause everyone to drop their references */
2597 route->drop_references ();
2599 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2601 /* save the new state of the world */
2603 if (save_state (_current_snapshot_name)) {
2604 save_history (_current_snapshot_name);
2609 Session::route_mute_changed (void* /*src*/)
2615 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2617 boost::shared_ptr<Route> route = wpr.lock();
2619 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2623 if (route->listening_via_monitor ()) {
2625 if (Config->get_exclusive_solo()) {
2626 /* new listen: disable all other listen */
2627 boost::shared_ptr<RouteList> r = routes.reader ();
2628 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2629 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
2632 (*i)->set_listen (false, this);
2638 } else if (_listen_cnt > 0) {
2643 update_route_solo_state ();
2646 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2648 boost::shared_ptr<Route> route = wpr.lock ();
2651 /* should not happen */
2652 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2656 bool send_changed = false;
2658 if (route->solo_isolated()) {
2659 if (_solo_isolated_cnt == 0) {
2660 send_changed = true;
2662 _solo_isolated_cnt++;
2663 } else if (_solo_isolated_cnt > 0) {
2664 _solo_isolated_cnt--;
2665 if (_solo_isolated_cnt == 0) {
2666 send_changed = true;
2671 IsolatedChanged (); /* EMIT SIGNAL */
2676 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2678 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2680 if (!self_solo_change) {
2681 // session doesn't care about changes to soloed-by-others
2685 if (solo_update_disabled) {
2687 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2691 boost::shared_ptr<Route> route = wpr.lock ();
2694 boost::shared_ptr<RouteList> r = routes.reader ();
2697 if (route->self_soloed()) {
2703 RouteGroup* rg = route->route_group ();
2704 bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2706 if (delta == 1 && Config->get_exclusive_solo()) {
2708 /* new solo: disable all other solos, but not the group if its solo-enabled */
2710 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2711 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2712 (leave_group_alone && ((*i)->route_group() == rg))) {
2715 (*i)->set_solo (false, this);
2719 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2721 solo_update_disabled = true;
2723 RouteList uninvolved;
2725 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2727 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2728 bool via_sends_only;
2729 bool in_signal_flow;
2731 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2732 (leave_group_alone && ((*i)->route_group() == rg))) {
2736 in_signal_flow = false;
2738 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2740 if ((*i)->feeds (route, &via_sends_only)) {
2741 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2742 if (!via_sends_only) {
2743 if (!route->soloed_by_others_upstream()) {
2744 (*i)->mod_solo_by_others_downstream (delta);
2747 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2749 in_signal_flow = true;
2751 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2754 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2756 if (route->feeds (*i, &via_sends_only)) {
2757 /* propagate solo upstream only if routing other than
2758 sends is involved, but do consider the other route
2759 (*i) to be part of the signal flow even if only
2762 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2766 route->soloed_by_others_downstream(),
2767 route->soloed_by_others_upstream()));
2768 if (!via_sends_only) {
2769 if (!route->soloed_by_others_downstream()) {
2770 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2771 (*i)->mod_solo_by_others_upstream (delta);
2773 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2776 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2778 in_signal_flow = true;
2780 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2783 if (!in_signal_flow) {
2784 uninvolved.push_back (*i);
2788 solo_update_disabled = false;
2789 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2791 update_route_solo_state (r);
2793 /* now notify that the mute state of the routes not involved in the signal
2794 pathway of the just-solo-changed route may have altered.
2797 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2798 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2799 (*i)->mute_changed (this);
2802 SoloChanged (); /* EMIT SIGNAL */
2807 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2809 /* now figure out if anything that matters is soloed (or is "listening")*/
2811 bool something_soloed = false;
2812 uint32_t listeners = 0;
2813 uint32_t isolated = 0;
2816 r = routes.reader();
2819 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2820 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
2821 something_soloed = true;
2824 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
2825 if (Config->get_solo_control_is_listen_control()) {
2828 (*i)->set_listen (false, this);
2832 if ((*i)->solo_isolated()) {
2837 if (something_soloed != _non_soloed_outs_muted) {
2838 _non_soloed_outs_muted = something_soloed;
2839 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2842 _listen_cnt = listeners;
2844 if (isolated != _solo_isolated_cnt) {
2845 _solo_isolated_cnt = isolated;
2846 IsolatedChanged (); /* EMIT SIGNAL */
2849 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2850 something_soloed, listeners, isolated));
2853 boost::shared_ptr<RouteList>
2854 Session::get_routes_with_internal_returns() const
2856 boost::shared_ptr<RouteList> r = routes.reader ();
2857 boost::shared_ptr<RouteList> rl (new RouteList);
2859 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2860 if ((*i)->internal_return ()) {
2868 Session::io_name_is_legal (const std::string& name)
2870 boost::shared_ptr<RouteList> r = routes.reader ();
2872 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2873 if ((*i)->name() == name) {
2877 if ((*i)->has_io_processor_named (name)) {
2886 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2889 vector<string> connections;
2891 /* if we are passed only a single route and we're not told to turn
2892 * others off, then just do the simple thing.
2895 if (flip_others == false && rl->size() == 1) {
2896 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2898 mt->set_input_active (onoff);
2903 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2905 PortSet& ps ((*rt)->input()->ports());
2907 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2908 p->get_connections (connections);
2911 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2912 routes_using_input_from (*s, rl2);
2915 /* scan all relevant routes to see if others are on or off */
2917 bool others_are_already_on = false;
2919 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2921 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2927 if ((*r) != (*rt)) {
2928 if (mt->input_active()) {
2929 others_are_already_on = true;
2932 /* this one needs changing */
2933 mt->set_input_active (onoff);
2939 /* globally reverse other routes */
2941 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2942 if ((*r) != (*rt)) {
2943 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2945 mt->set_input_active (!others_are_already_on);
2954 Session::routes_using_input_from (const string& str, RouteList& rl)
2956 boost::shared_ptr<RouteList> r = routes.reader();
2958 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2959 if ((*i)->input()->connected_to (str)) {
2965 boost::shared_ptr<Route>
2966 Session::route_by_name (string name)
2968 boost::shared_ptr<RouteList> r = routes.reader ();
2970 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2971 if ((*i)->name() == name) {
2976 return boost::shared_ptr<Route> ((Route*) 0);
2979 boost::shared_ptr<Route>
2980 Session::route_by_id (PBD::ID id)
2982 boost::shared_ptr<RouteList> r = routes.reader ();
2984 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2985 if ((*i)->id() == id) {
2990 return boost::shared_ptr<Route> ((Route*) 0);
2993 boost::shared_ptr<Track>
2994 Session::track_by_diskstream_id (PBD::ID id)
2996 boost::shared_ptr<RouteList> r = routes.reader ();
2998 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2999 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3000 if (t && t->using_diskstream_id (id)) {
3005 return boost::shared_ptr<Track> ();
3008 boost::shared_ptr<Route>
3009 Session::route_by_remote_id (uint32_t id)
3011 boost::shared_ptr<RouteList> r = routes.reader ();
3013 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3014 if ((*i)->remote_control_id() == id) {
3019 return boost::shared_ptr<Route> ((Route*) 0);
3023 Session::playlist_region_added (boost::weak_ptr<Region> w)
3025 boost::shared_ptr<Region> r = w.lock ();
3030 /* These are the operations that are currently in progress... */
3031 list<GQuark> curr = _current_trans_quarks;
3034 /* ...and these are the operations during which we want to update
3035 the session range location markers.
3038 ops.push_back (Operations::capture);
3039 ops.push_back (Operations::paste);
3040 ops.push_back (Operations::duplicate_region);
3041 ops.push_back (Operations::insert_file);
3042 ops.push_back (Operations::insert_region);
3043 ops.push_back (Operations::drag_region_brush);
3044 ops.push_back (Operations::region_drag);
3045 ops.push_back (Operations::selection_grab);
3046 ops.push_back (Operations::region_fill);
3047 ops.push_back (Operations::fill_selection);
3048 ops.push_back (Operations::create_region);
3049 ops.push_back (Operations::region_copy);
3050 ops.push_back (Operations::fixed_time_region_copy);
3053 /* See if any of the current operations match the ones that we want */
3055 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3057 /* If so, update the session range markers */
3059 maybe_update_session_range (r->position (), r->last_frame ());
3063 /** Update the session range markers if a is before the current start or
3064 * b is after the current end.
3067 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3069 if (_state_of_the_state & Loading) {
3073 if (_session_range_location == 0) {
3075 add_session_range_location (a, b);
3079 if (a < _session_range_location->start()) {
3080 _session_range_location->set_start (a);
3083 if (b > _session_range_location->end()) {
3084 _session_range_location->set_end (b);
3090 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3092 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3093 maybe_update_session_range (i->to, i->to + i->length);
3098 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3100 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3101 maybe_update_session_range (i->from, i->to);
3105 /* Region management */
3107 boost::shared_ptr<Region>
3108 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3110 const RegionFactory::RegionMap& regions (RegionFactory::regions());
3111 RegionFactory::RegionMap::const_iterator i;
3112 boost::shared_ptr<Region> region;
3114 Glib::Threads::Mutex::Lock lm (region_lock);
3116 for (i = regions.begin(); i != regions.end(); ++i) {
3120 if (region->whole_file()) {
3122 if (child->source_equivalent (region)) {
3128 return boost::shared_ptr<Region> ();
3132 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3134 set<boost::shared_ptr<Region> > relevant_regions;
3136 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3137 RegionFactory::get_regions_using_source (*s, relevant_regions);
3140 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3141 set<boost::shared_ptr<Region> >::iterator tmp;
3146 playlists->destroy_region (*r);
3147 RegionFactory::map_remove (*r);
3149 (*r)->drop_sources ();
3150 (*r)->drop_references ();
3152 relevant_regions.erase (r);
3157 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3160 Glib::Threads::Mutex::Lock ls (source_lock);
3161 /* remove from the main source list */
3162 sources.erase ((*s)->id());
3165 (*s)->mark_for_remove ();
3166 (*s)->drop_references ();
3175 Session::remove_last_capture ()
3177 list<boost::shared_ptr<Source> > srcs;
3179 boost::shared_ptr<RouteList> rl = routes.reader ();
3180 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3181 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3186 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3189 srcs.insert (srcs.end(), l.begin(), l.end());
3194 destroy_sources (srcs);
3196 save_state (_current_snapshot_name);
3201 /* Source Management */
3204 Session::add_source (boost::shared_ptr<Source> source)
3206 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3207 pair<SourceMap::iterator,bool> result;
3209 entry.first = source->id();
3210 entry.second = source;
3213 Glib::Threads::Mutex::Lock lm (source_lock);
3214 result = sources.insert (entry);
3217 if (result.second) {
3219 /* yay, new source */
3221 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3224 if (!fs->within_session()) {
3225 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3231 boost::shared_ptr<AudioFileSource> afs;
3233 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3234 if (Config->get_auto_analyse_audio()) {
3235 Analyser::queue_source_for_analysis (source, false);
3239 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3244 Session::remove_source (boost::weak_ptr<Source> src)
3246 if (_state_of_the_state & Deletion) {
3250 SourceMap::iterator i;
3251 boost::shared_ptr<Source> source = src.lock();
3258 Glib::Threads::Mutex::Lock lm (source_lock);
3260 if ((i = sources.find (source->id())) != sources.end()) {
3265 if (!(_state_of_the_state & InCleanup)) {
3267 /* save state so we don't end up with a session file
3268 referring to non-existent sources.
3271 save_state (_current_snapshot_name);
3275 boost::shared_ptr<Source>
3276 Session::source_by_id (const PBD::ID& id)
3278 Glib::Threads::Mutex::Lock lm (source_lock);
3279 SourceMap::iterator i;
3280 boost::shared_ptr<Source> source;
3282 if ((i = sources.find (id)) != sources.end()) {
3289 boost::shared_ptr<Source>
3290 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3292 Glib::Threads::Mutex::Lock lm (source_lock);
3294 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3295 boost::shared_ptr<AudioFileSource> afs
3296 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3298 if (afs && afs->path() == path && chn == afs->channel()) {
3302 return boost::shared_ptr<Source>();
3306 Session::count_sources_by_origin (const string& path)
3309 Glib::Threads::Mutex::Lock lm (source_lock);
3311 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3312 boost::shared_ptr<FileSource> fs
3313 = boost::dynamic_pointer_cast<FileSource>(i->second);
3315 if (fs && fs->origin() == path) {
3325 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3328 string old_basename = PBD::basename_nosuffix (oldname);
3329 string new_legalized = legalize_for_path (newname);
3331 /* note: we know (or assume) the old path is already valid */
3335 /* destructive file sources have a name of the form:
3337 /path/to/Tnnnn-NAME(%[LR])?.wav
3339 the task here is to replace NAME with the new name.
3344 string::size_type dash;
3346 dir = Glib::path_get_dirname (path);
3347 path = Glib::path_get_basename (path);
3349 /* '-' is not a legal character for the NAME part of the path */
3351 if ((dash = path.find_last_of ('-')) == string::npos) {
3355 prefix = path.substr (0, dash);
3359 path += new_legalized;
3360 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3361 path = Glib::build_filename (dir, path);
3365 /* non-destructive file sources have a name of the form:
3367 /path/to/NAME-nnnnn(%[LR])?.ext
3369 the task here is to replace NAME with the new name.
3374 string::size_type dash;
3375 string::size_type postfix;
3377 dir = Glib::path_get_dirname (path);
3378 path = Glib::path_get_basename (path);
3380 /* '-' is not a legal character for the NAME part of the path */
3382 if ((dash = path.find_last_of ('-')) == string::npos) {
3386 suffix = path.substr (dash+1);
3388 // Suffix is now everything after the dash. Now we need to eliminate
3389 // the nnnnn part, which is done by either finding a '%' or a '.'
3391 postfix = suffix.find_last_of ("%");
3392 if (postfix == string::npos) {
3393 postfix = suffix.find_last_of ('.');
3396 if (postfix != string::npos) {
3397 suffix = suffix.substr (postfix);
3399 error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3403 const uint32_t limit = 10000;
3404 char buf[PATH_MAX+1];
3406 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3408 snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3410 if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3411 path = Glib::build_filename (dir, buf);
3419 fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3428 /** Return the full path (in some session directory) for a new within-session source.
3429 * \a name must be a session-unique name that does not contain slashes
3430 * (e.g. as returned by new_*_source_name)
3433 Session::new_source_path_from_name (DataType type, const string& name)
3435 assert(name.find("/") == string::npos);
3437 SessionDirectory sdir(get_best_session_directory_for_new_source());
3440 if (type == DataType::AUDIO) {
3441 p = sdir.sound_path();
3442 } else if (type == DataType::MIDI) {
3443 p = sdir.midi_path();
3445 error << "Unknown source type, unable to create file path" << endmsg;
3449 return Glib::build_filename (p, name);
3453 Session::peak_path (string base) const
3455 return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3458 /** Return a unique name based on \a base for a new internal audio source */
3460 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3463 char buf[PATH_MAX+1];
3464 const uint32_t limit = 10000;
3466 string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3469 legalized = legalize_for_path (base);
3471 // Find a "version" of the base name that doesn't exist in any of the possible directories.
3472 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3474 vector<space_and_path>::iterator i;
3475 uint32_t existing = 0;
3477 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3482 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3483 cnt, legalized.c_str(), ext.c_str());
3484 } else if (nchan == 2) {
3486 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3487 cnt, legalized.c_str(), ext.c_str());
3489 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3490 cnt, legalized.c_str(), ext.c_str());
3492 } else if (nchan < 26) {
3493 snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3494 cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3496 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3497 cnt, legalized.c_str(), ext.c_str());
3503 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3504 } else if (nchan == 2) {
3506 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3508 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3510 } else if (nchan < 26) {
3511 snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3513 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3517 SessionDirectory sdir((*i).path);
3519 string spath = sdir.sound_path();
3521 /* note that we search *without* the extension so that
3522 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3523 in the event that this new name is required for
3524 a file format change.
3527 if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3533 if (existing == 0) {
3538 error << string_compose(
3539 _("There are already %1 recordings for %2, which I consider too many."),
3540 limit, base) << endmsg;
3542 throw failed_constructor();
3546 return Glib::path_get_basename (buf);
3549 /** Create a new within-session audio source */
3550 boost::shared_ptr<AudioFileSource>
3551 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3553 const string name = new_audio_source_name (n, n_chans, chan, destructive);
3554 const string path = new_source_path_from_name(DataType::AUDIO, name);
3556 return boost::dynamic_pointer_cast<AudioFileSource> (
3557 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3560 /** Return a unique name based on \a base for a new internal MIDI source */
3562 Session::new_midi_source_name (const string& base)
3565 char buf[PATH_MAX+1];
3566 const uint32_t limit = 10000;
3570 legalized = legalize_for_path (base);
3572 // Find a "version" of the file name that doesn't exist in any of the possible directories.
3573 for (cnt = 1; cnt <= limit; ++cnt) {
3575 vector<space_and_path>::iterator i;
3576 uint32_t existing = 0;
3578 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3580 SessionDirectory sdir((*i).path);
3582 std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3584 snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3586 if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3591 if (existing == 0) {
3596 error << string_compose(
3597 _("There are already %1 recordings for %2, which I consider too many."),
3598 limit, base) << endmsg;
3600 throw failed_constructor();
3604 return Glib::path_get_basename(buf);
3608 /** Create a new within-session MIDI source */
3609 boost::shared_ptr<MidiSource>
3610 Session::create_midi_source_for_session (Track* track, string const & n)
3612 /* try to use the existing write source for the track, to keep numbering sane
3616 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3620 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3623 assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3624 return boost::dynamic_pointer_cast<MidiSource> (l.front());
3628 const string name = new_midi_source_name (n);
3629 const string path = new_source_path_from_name (DataType::MIDI, name);
3631 return boost::dynamic_pointer_cast<SMFSource> (
3632 SourceFactory::createWritable (
3633 DataType::MIDI, *this, path, false, frame_rate()));
3638 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3640 if (playlist->hidden()) {
3644 playlists->add (playlist);
3647 playlist->release();
3654 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3656 if (_state_of_the_state & Deletion) {
3660 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3666 playlists->remove (playlist);
3672 Session::set_audition (boost::shared_ptr<Region> r)
3674 pending_audition_region = r;
3675 add_post_transport_work (PostTransportAudition);
3676 _butler->schedule_transport_work ();
3680 Session::audition_playlist ()
3682 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3683 ev->region.reset ();
3688 Session::non_realtime_set_audition ()
3690 assert (pending_audition_region);
3691 auditioner->audition_region (pending_audition_region);
3692 pending_audition_region.reset ();
3693 AuditionActive (true); /* EMIT SIGNAL */
3697 Session::audition_region (boost::shared_ptr<Region> r)
3699 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3705 Session::cancel_audition ()
3707 if (auditioner->auditioning()) {
3708 auditioner->cancel_audition ();
3709 AuditionActive (false); /* EMIT SIGNAL */
3714 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3716 if (a->is_monitor()) {
3719 if (b->is_monitor()) {
3722 return a->order_key () < b->order_key ();
3726 Session::is_auditioning () const
3728 /* can be called before we have an auditioner object */
3730 return auditioner->auditioning();
3737 Session::graph_reordered ()
3739 /* don't do this stuff if we are setting up connections
3740 from a set_state() call or creating new tracks. Ditto for deletion.
3743 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3747 /* every track/bus asked for this to be handled but it was deferred because
3748 we were connecting. do it now.
3751 request_input_change_handling ();
3755 /* force all diskstreams to update their capture offset values to
3756 reflect any changes in latencies within the graph.
3759 boost::shared_ptr<RouteList> rl = routes.reader ();
3760 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3761 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3763 tr->set_capture_offset ();
3768 /** @return Number of frames that there is disk space available to write,
3771 boost::optional<framecnt_t>
3772 Session::available_capture_duration ()
3774 Glib::Threads::Mutex::Lock lm (space_lock);
3776 if (_total_free_4k_blocks_uncertain) {
3777 return boost::optional<framecnt_t> ();
3780 float sample_bytes_on_disk = 4.0; // keep gcc happy
3782 switch (config.get_native_file_data_format()) {
3784 sample_bytes_on_disk = 4.0;
3788 sample_bytes_on_disk = 3.0;
3792 sample_bytes_on_disk = 2.0;
3796 /* impossible, but keep some gcc versions happy */
3797 fatal << string_compose (_("programming error: %1"),
3798 X_("illegal native file data format"))
3803 double scale = 4096.0 / sample_bytes_on_disk;
3805 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3806 return max_framecnt;
3809 return (framecnt_t) floor (_total_free_4k_blocks * scale);
3813 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3816 RCUWriter<BundleList> writer (_bundles);
3817 boost::shared_ptr<BundleList> b = writer.get_copy ();
3818 b->push_back (bundle);
3821 BundleAdded (bundle); /* EMIT SIGNAL */
3827 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3829 bool removed = false;
3832 RCUWriter<BundleList> writer (_bundles);
3833 boost::shared_ptr<BundleList> b = writer.get_copy ();
3834 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3836 if (i != b->end()) {
3843 BundleRemoved (bundle); /* EMIT SIGNAL */
3849 boost::shared_ptr<Bundle>
3850 Session::bundle_by_name (string name) const
3852 boost::shared_ptr<BundleList> b = _bundles.reader ();
3854 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3855 if ((*i)->name() == name) {
3860 return boost::shared_ptr<Bundle> ();
3864 Session::tempo_map_changed (const PropertyChange&)
3868 playlists->update_after_tempo_map_change ();
3870 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3876 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3878 for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3879 (*i)->recompute_frames_from_bbt ();
3883 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3884 * the given count with the current block size.
3887 Session::ensure_buffers (ChanCount howmany)
3889 BufferManager::ensure_buffers (howmany);
3893 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3895 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3896 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3901 Session::next_insert_id ()
3903 /* this doesn't really loop forever. just think about it */
3906 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3907 if (!insert_bitset[n]) {
3908 insert_bitset[n] = true;
3914 /* none available, so resize and try again */
3916 insert_bitset.resize (insert_bitset.size() + 16, false);
3921 Session::next_send_id ()
3923 /* this doesn't really loop forever. just think about it */
3926 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3927 if (!send_bitset[n]) {
3928 send_bitset[n] = true;
3934 /* none available, so resize and try again */
3936 send_bitset.resize (send_bitset.size() + 16, false);
3941 Session::next_aux_send_id ()
3943 /* this doesn't really loop forever. just think about it */
3946 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3947 if (!aux_send_bitset[n]) {
3948 aux_send_bitset[n] = true;
3954 /* none available, so resize and try again */
3956 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3961 Session::next_return_id ()
3963 /* this doesn't really loop forever. just think about it */
3966 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3967 if (!return_bitset[n]) {
3968 return_bitset[n] = true;
3974 /* none available, so resize and try again */
3976 return_bitset.resize (return_bitset.size() + 16, false);
3981 Session::mark_send_id (uint32_t id)
3983 if (id >= send_bitset.size()) {
3984 send_bitset.resize (id+16, false);
3986 if (send_bitset[id]) {
3987 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3989 send_bitset[id] = true;
3993 Session::mark_aux_send_id (uint32_t id)
3995 if (id >= aux_send_bitset.size()) {
3996 aux_send_bitset.resize (id+16, false);
3998 if (aux_send_bitset[id]) {
3999 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4001 aux_send_bitset[id] = true;
4005 Session::mark_return_id (uint32_t id)
4007 if (id >= return_bitset.size()) {
4008 return_bitset.resize (id+16, false);
4010 if (return_bitset[id]) {
4011 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4013 return_bitset[id] = true;
4017 Session::mark_insert_id (uint32_t id)
4019 if (id >= insert_bitset.size()) {
4020 insert_bitset.resize (id+16, false);
4022 if (insert_bitset[id]) {
4023 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4025 insert_bitset[id] = true;
4029 Session::unmark_send_id (uint32_t id)
4031 if (id < send_bitset.size()) {
4032 send_bitset[id] = false;
4037 Session::unmark_aux_send_id (uint32_t id)
4039 if (id < aux_send_bitset.size()) {
4040 aux_send_bitset[id] = false;
4045 Session::unmark_return_id (uint32_t id)
4047 if (id < return_bitset.size()) {
4048 return_bitset[id] = false;
4053 Session::unmark_insert_id (uint32_t id)
4055 if (id < insert_bitset.size()) {
4056 insert_bitset[id] = false;
4061 Session::reset_native_file_format ()
4063 boost::shared_ptr<RouteList> rl = routes.reader ();
4064 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4065 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4067 /* don't save state as we do this, there's no point
4070 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4071 tr->reset_write_sources (false);
4072 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4078 Session::route_name_unique (string n) const
4080 boost::shared_ptr<RouteList> r = routes.reader ();
4082 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4083 if ((*i)->name() == n) {
4092 Session::route_name_internal (string n) const
4094 if (auditioner && auditioner->name() == n) {
4098 if (_click_io && _click_io->name() == n) {
4106 Session::freeze_all (InterThreadInfo& itt)
4108 boost::shared_ptr<RouteList> r = routes.reader ();
4110 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4112 boost::shared_ptr<Track> t;
4114 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4115 /* XXX this is wrong because itt.progress will keep returning to zero at the start
4125 boost::shared_ptr<Region>
4126 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
4127 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4128 InterThreadInfo& itt,
4129 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4132 boost::shared_ptr<Region> result;
4133 boost::shared_ptr<Playlist> playlist;
4134 boost::shared_ptr<AudioFileSource> fsource;
4136 char buf[PATH_MAX+1];
4137 ChanCount diskstream_channels (track.n_channels());
4138 framepos_t position;
4139 framecnt_t this_chunk;
4142 SessionDirectory sdir(get_best_session_directory_for_new_source ());
4143 const string sound_dir = sdir.sound_path();
4144 framepos_t len = end - start;
4145 bool need_block_size_reset = false;
4147 ChanCount const max_proc = track.max_processor_streams ();
4150 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4151 end, start) << endmsg;
4155 const framecnt_t chunk_size = (256 * 1024)/4;
4157 // block all process callback handling
4159 block_processing ();
4161 /* call tree *MUST* hold route_lock */
4163 if ((playlist = track.playlist()) == 0) {
4167 ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4169 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
4171 for (x = 0; x < 99999; ++x) {
4172 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());
4173 if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
4179 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4184 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4185 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
4188 catch (failed_constructor& err) {
4189 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4193 srcs.push_back (fsource);
4196 /* tell redirects that care that we are about to use a much larger
4197 * blocksize. this will flush all plugins too, so that they are ready
4198 * to be used for this process.
4201 need_block_size_reset = true;
4202 track.set_block_size (chunk_size);
4207 /* create a set of reasonably-sized buffers */
4208 buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4209 buffers.set_count (max_proc);
4211 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4212 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4214 afs->prepare_for_peakfile_writes ();
4217 while (to_do && !itt.cancel) {
4219 this_chunk = min (to_do, chunk_size);
4221 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4226 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4227 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4230 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4236 start += this_chunk;
4237 to_do -= this_chunk;
4239 itt.progress = (float) (1.0 - ((double) to_do / len));
4248 xnow = localtime (&now);
4250 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4251 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4254 afs->update_header (position, *xnow, now);
4255 afs->flush_header ();
4259 /* construct a region to represent the bounced material */
4263 plist.add (Properties::start, 0);
4264 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4265 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4267 result = RegionFactory::create (srcs, plist);
4273 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4274 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4277 afs->mark_for_remove ();
4280 (*src)->drop_references ();
4284 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4285 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4288 afs->done_with_peakfile_writes ();
4293 if (need_block_size_reset) {
4294 track.set_block_size (get_block_size());
4297 unblock_processing ();
4303 Session::gain_automation_buffer() const
4305 return ProcessThread::gain_automation_buffer ();
4309 Session::send_gain_automation_buffer() const
4311 return ProcessThread::send_gain_automation_buffer ();
4315 Session::pan_automation_buffer() const
4317 return ProcessThread::pan_automation_buffer ();
4321 Session::get_silent_buffers (ChanCount count)
4323 return ProcessThread::get_silent_buffers (count);
4327 Session::get_scratch_buffers (ChanCount count, bool silence)
4329 return ProcessThread::get_scratch_buffers (count, silence);
4333 Session::get_route_buffers (ChanCount count, bool silence)
4335 return ProcessThread::get_route_buffers (count, silence);
4340 Session::get_mix_buffers (ChanCount count)
4342 return ProcessThread::get_mix_buffers (count);
4346 Session::ntracks () const
4349 boost::shared_ptr<RouteList> r = routes.reader ();
4351 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4352 if (boost::dynamic_pointer_cast<Track> (*i)) {
4361 Session::nbusses () const
4364 boost::shared_ptr<RouteList> r = routes.reader ();
4366 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4367 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4376 Session::add_automation_list(AutomationList *al)
4378 automation_lists[al->id()] = al;
4381 /** @return true if there is at least one record-enabled track, otherwise false */
4383 Session::have_rec_enabled_track () const
4385 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4388 /** Update the state of our rec-enabled tracks flag */
4390 Session::update_have_rec_enabled_track ()
4392 boost::shared_ptr<RouteList> rl = routes.reader ();
4393 RouteList::iterator i = rl->begin();
4394 while (i != rl->end ()) {
4396 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4397 if (tr && tr->record_enabled ()) {
4404 int const old = g_atomic_int_get (&_have_rec_enabled_track);
4406 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4408 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4409 RecordStateChanged (); /* EMIT SIGNAL */
4414 Session::listen_position_changed ()
4416 boost::shared_ptr<RouteList> r = routes.reader ();
4418 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4419 (*i)->listen_position_changed ();
4424 Session::solo_control_mode_changed ()
4426 /* cancel all solo or all listen when solo control mode changes */
4429 set_solo (get_routes(), false);
4430 } else if (listening()) {
4431 set_listen (get_routes(), false);
4435 /** Called when a property of one of our route groups changes */
4437 Session::route_group_property_changed (RouteGroup* rg)
4439 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4442 /** Called when a route is added to one of our route groups */
4444 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4446 RouteAddedToRouteGroup (rg, r);
4449 /** Called when a route is removed from one of our route groups */
4451 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4453 RouteRemovedFromRouteGroup (rg, r);
4456 boost::shared_ptr<RouteList>
4457 Session::get_routes_with_regions_at (framepos_t const p) const
4459 boost::shared_ptr<RouteList> r = routes.reader ();
4460 boost::shared_ptr<RouteList> rl (new RouteList);
4462 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4463 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4468 boost::shared_ptr<Playlist> pl = tr->playlist ();
4473 if (pl->has_region_at (p)) {
4482 Session::goto_end ()
4484 if (_session_range_location) {
4485 request_locate (_session_range_location->end(), false);
4487 request_locate (0, false);
4492 Session::goto_start ()
4494 if (_session_range_location) {
4495 request_locate (_session_range_location->start(), false);
4497 request_locate (0, false);
4502 Session::current_start_frame () const
4504 return _session_range_location ? _session_range_location->start() : 0;
4508 Session::current_end_frame () const
4510 return _session_range_location ? _session_range_location->end() : 0;
4514 Session::add_session_range_location (framepos_t start, framepos_t end)
4516 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4517 _locations->add (_session_range_location);
4521 Session::step_edit_status_change (bool yn)
4527 send = (_step_editors == 0);
4532 send = (_step_editors == 1);
4535 if (_step_editors > 0) {
4541 StepEditStatusChange (val);
4547 Session::start_time_changed (framepos_t old)
4549 /* Update the auto loop range to match the session range
4550 (unless the auto loop range has been changed by the user)
4553 Location* s = _locations->session_range_location ();
4558 Location* l = _locations->auto_loop_location ();
4560 if (l && l->start() == old) {
4561 l->set_start (s->start(), true);
4566 Session::end_time_changed (framepos_t old)
4568 /* Update the auto loop range to match the session range
4569 (unless the auto loop range has been changed by the user)
4572 Location* s = _locations->session_range_location ();
4577 Location* l = _locations->auto_loop_location ();
4579 if (l && l->end() == old) {
4580 l->set_end (s->end(), true);
4585 Session::source_search_path (DataType type) const
4589 if (session_dirs.size() == 1) {
4591 case DataType::AUDIO:
4592 s.push_back (_session_dir->sound_path());
4594 case DataType::MIDI:
4595 s.push_back (_session_dir->midi_path());
4599 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4600 SessionDirectory sdir (i->path);
4602 case DataType::AUDIO:
4603 s.push_back (sdir.sound_path());
4605 case DataType::MIDI:
4606 s.push_back (sdir.midi_path());
4612 if (type == DataType::AUDIO) {
4613 const string sound_path_2X = _session_dir->sound_path_2X();
4614 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4615 if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
4616 s.push_back (sound_path_2X);
4621 /* now check the explicit (possibly user-specified) search path
4624 vector<string> dirs;
4627 case DataType::AUDIO:
4628 split (config.get_audio_search_path (), dirs, ':');
4630 case DataType::MIDI:
4631 split (config.get_midi_search_path (), dirs, ':');
4635 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4636 if (find (s.begin(), s.end(), *i) == s.end()) {
4643 for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4644 if (!search_path.empty()) {
4654 Session::ensure_search_path_includes (const string& path, DataType type)
4657 vector<string> dirs;
4664 case DataType::AUDIO:
4665 search_path = config.get_audio_search_path ();
4667 case DataType::MIDI:
4668 search_path = config.get_midi_search_path ();
4672 split (search_path, dirs, ':');
4674 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4675 /* No need to add this new directory if it has the same inode as
4676 an existing one; checking inode rather than name prevents duplicated
4677 directories when we are using symlinks.
4679 On Windows, I think we could just do if (*i == path) here.
4681 if (PBD::equivalent_paths (*i, path)) {
4686 if (!search_path.empty()) {
4690 search_path += path;
4693 case DataType::AUDIO:
4694 config.set_audio_search_path (search_path);
4696 case DataType::MIDI:
4697 config.set_midi_search_path (search_path);
4702 boost::shared_ptr<Speakers>
4703 Session::get_speakers()
4709 Session::unknown_processors () const
4713 boost::shared_ptr<RouteList> r = routes.reader ();
4714 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4715 list<string> t = (*i)->unknown_processors ();
4716 copy (t.begin(), t.end(), back_inserter (p));
4726 Session::update_latency (bool playback)
4728 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4730 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4734 boost::shared_ptr<RouteList> r = routes.reader ();
4735 framecnt_t max_latency = 0;
4738 /* reverse the list so that we work backwards from the last route to run to the first */
4739 RouteList* rl = routes.reader().get();
4740 r.reset (new RouteList (*rl));
4741 reverse (r->begin(), r->end());
4744 /* compute actual latency values for the given direction and store them all in per-port
4745 structures. this will also publish the same values (to JACK) so that computation of latency
4746 for routes can consistently use public latency values.
4749 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4750 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4753 /* because we latency compensate playback, our published playback latencies should
4754 be the same for all output ports - all material played back by ardour has
4755 the same latency, whether its caused by plugins or by latency compensation. since
4756 these may differ from the values computed above, reset all playback port latencies
4760 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4762 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4763 (*i)->set_public_port_latencies (max_latency, playback);
4768 post_playback_latency ();
4772 post_capture_latency ();
4775 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4779 Session::post_playback_latency ()
4781 set_worst_playback_latency ();
4783 boost::shared_ptr<RouteList> r = routes.reader ();
4785 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4786 if (!(*i)->is_auditioner() && ((*i)->active())) {
4787 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4791 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4792 (*i)->set_latency_compensation (_worst_track_latency);
4797 Session::post_capture_latency ()
4799 set_worst_capture_latency ();
4801 /* reflect any changes in capture latencies into capture offsets
4804 boost::shared_ptr<RouteList> rl = routes.reader();
4805 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4806 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4808 tr->set_capture_offset ();
4814 Session::initialize_latencies ()
4817 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4818 update_latency (false);
4819 update_latency (true);
4822 set_worst_io_latencies ();
4826 Session::set_worst_io_latencies ()
4828 set_worst_playback_latency ();
4829 set_worst_capture_latency ();
4833 Session::set_worst_playback_latency ()
4835 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4839 _worst_output_latency = 0;
4841 if (!_engine.connected()) {
4845 boost::shared_ptr<RouteList> r = routes.reader ();
4847 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4848 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4851 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4855 Session::set_worst_capture_latency ()
4857 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4861 _worst_input_latency = 0;
4863 if (!_engine.connected()) {
4867 boost::shared_ptr<RouteList> r = routes.reader ();
4869 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4870 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4873 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4877 Session::update_latency_compensation (bool force_whole_graph)
4879 bool some_track_latency_changed = false;
4881 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4885 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4887 _worst_track_latency = 0;
4889 boost::shared_ptr<RouteList> r = routes.reader ();
4891 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4892 if (!(*i)->is_auditioner() && ((*i)->active())) {
4894 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4895 some_track_latency_changed = true;
4897 _worst_track_latency = max (tl, _worst_track_latency);
4901 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4902 (some_track_latency_changed ? "yes" : "no")));
4904 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4906 if (some_track_latency_changed || force_whole_graph) {
4907 _engine.update_latencies ();
4911 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4912 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4916 tr->set_capture_offset ();
4921 Session::session_name_is_legal (const string& path)
4923 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4925 for (int i = 0; illegal_chars[i]; ++i) {
4926 if (path.find (illegal_chars[i]) != string::npos) {
4927 return illegal_chars[i];
4935 Session::next_control_id () const
4939 /* the monitor bus remote ID is in a different
4940 * "namespace" than regular routes. its existence doesn't
4941 * affect normal (low) numbered routes.
4948 return nroutes() - subtract;
4952 Session::notify_remote_id_change ()
4954 if (deletion_in_progress()) {
4958 switch (Config->get_remote_model()) {
4960 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4968 Session::sync_order_keys ()
4970 if (deletion_in_progress()) {
4974 /* tell everyone that something has happened to the sort keys
4975 and let them sync up with the change(s)
4976 this will give objects that manage the sort order keys the
4977 opportunity to keep them in sync if they wish to.
4980 DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
4982 Route::SyncOrderKeys (); /* EMIT SIGNAL */
4984 DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
4988 Session::operation_in_progress (GQuark op) const
4990 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4993 boost::shared_ptr<Port>
4994 Session::ltc_input_port () const
4996 return _ltc_input->nth (0);
4999 boost::shared_ptr<Port>
5000 Session::ltc_output_port () const
5002 return _ltc_output->nth (0);
5006 Session::reconnect_ltc_input ()
5010 string src = Config->get_ltc_source_port();
5012 _ltc_input->disconnect (this);
5014 if (src != _("None") && !src.empty()) {
5015 _ltc_input->nth (0)->connect (src);
5021 Session::reconnect_ltc_output ()
5026 string src = Config->get_ltc_sink_port();
5028 _ltc_output->disconnect (this);
5030 if (src != _("None") && !src.empty()) {
5031 _ltc_output->nth (0)->connect (src);