2 Copyright (C) 1999-2010 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <cstdio> /* sprintf(3) ... grrr */
33 #include <glibmm/threads.h>
34 #include <glibmm/miscutils.h>
35 #include <glibmm/fileutils.h>
37 #include <boost/algorithm/string/erase.hpp>
39 #include "pbd/error.h"
40 #include "pbd/boost_debug.h"
41 #include "pbd/pathscanner.h"
42 #include "pbd/stl_delete.h"
43 #include "pbd/basename.h"
44 #include "pbd/stacktrace.h"
45 #include "pbd/file_utils.h"
46 #include "pbd/convert.h"
47 #include "pbd/unwind.h"
48 #include "pbd/search_path.h"
50 #include "ardour/amp.h"
51 #include "ardour/analyser.h"
52 #include "ardour/async_midi_port.h"
53 #include "ardour/audio_buffer.h"
54 #include "ardour/audio_diskstream.h"
55 #include "ardour/audio_port.h"
56 #include "ardour/audio_track.h"
57 #include "ardour/audioengine.h"
58 #include "ardour/audiofilesource.h"
59 #include "ardour/auditioner.h"
60 #include "ardour/buffer_manager.h"
61 #include "ardour/buffer_set.h"
62 #include "ardour/bundle.h"
63 #include "ardour/butler.h"
64 #include "ardour/click.h"
65 #include "ardour/control_protocol_manager.h"
66 #include "ardour/data_type.h"
67 #include "ardour/debug.h"
68 #include "ardour/filename_extensions.h"
69 #include "ardour/graph.h"
70 #include "ardour/midiport_manager.h"
71 #include "ardour/midi_track.h"
72 #include "ardour/midi_ui.h"
73 #include "ardour/operations.h"
74 #include "ardour/playlist.h"
75 #include "ardour/plugin.h"
76 #include "ardour/plugin_insert.h"
77 #include "ardour/process_thread.h"
78 #include "ardour/rc_configuration.h"
79 #include "ardour/recent_sessions.h"
80 #include "ardour/region.h"
81 #include "ardour/region_factory.h"
82 #include "ardour/route_graph.h"
83 #include "ardour/route_group.h"
84 #include "ardour/send.h"
85 #include "ardour/session.h"
86 #include "ardour/session_directory.h"
87 #include "ardour/session_playlists.h"
88 #include "ardour/smf_source.h"
89 #include "ardour/source_factory.h"
90 #include "ardour/speakers.h"
91 #include "ardour/utils.h"
93 #include "midi++/port.h"
94 #include "midi++/mmc.h"
105 using namespace ARDOUR;
108 bool Session::_disable_all_loaded_plugins = false;
110 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
111 PBD::Signal1<void,std::string> Session::Dialog;
112 PBD::Signal0<int> Session::AskAboutPendingState;
113 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
114 PBD::Signal0<void> Session::SendFeedback;
115 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
117 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
118 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
119 PBD::Signal2<void,std::string, std::string> Session::Exported;
120 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
121 PBD::Signal0<void> Session::Quit;
122 PBD::Signal0<void> Session::FeedbackDetected;
123 PBD::Signal0<void> Session::SuccessfulGraphSort;
124 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
126 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
127 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
129 /** @param snapshot_name Snapshot name, without .ardour suffix */
130 Session::Session (AudioEngine &eng,
131 const string& fullpath,
132 const string& snapshot_name,
133 BusProfile* bus_profile,
135 : playlists (new SessionPlaylists)
137 , process_function (&Session::process_with_events)
138 , waiting_for_sync_offset (false)
139 , _base_frame_rate (0)
140 , _current_frame_rate (0)
141 , _nominal_frame_rate (0)
142 , transport_sub_state (0)
143 , _record_status (Disabled)
144 , _transport_frame (0)
145 , _session_range_location (0)
148 , _transport_speed (0)
149 , _default_transport_speed (1.0)
150 , _last_transport_speed (0)
151 , _target_transport_speed (0.0)
152 , auto_play_legal (false)
153 , _last_slave_transport_frame (0)
154 , maximum_output_latency (0)
155 , _requested_return_frame (-1)
156 , current_block_size (0)
157 , _worst_output_latency (0)
158 , _worst_input_latency (0)
159 , _worst_track_latency (0)
160 , _have_captured (false)
163 , _non_soloed_outs_muted (false)
165 , _solo_isolated_cnt (0)
167 , _was_seamless (Config->get_seamless_loop ())
168 , _under_nsm_control (false)
169 , delta_accumulator_cnt (0)
170 , average_slave_delta (1800) // !!! why 1800 ???
172 , have_first_delta_accumulator (false)
173 , _slave_state (Stopped)
174 , post_export_sync (false)
175 , post_export_position (0)
177 , _export_started (false)
178 , _export_rolling (false)
179 , _pre_export_mmc_enabled (false)
180 , _name (snapshot_name)
182 , _send_qf_mtc (false)
183 , _pframes_since_last_mtc (0)
184 , session_midi_feedback (0)
186 , loop_changing (false)
188 , _session_dir (new SessionDirectory (fullpath))
189 , _current_snapshot_name (snapshot_name)
191 , state_was_pending (false)
192 , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
193 , _last_roll_location (0)
194 , _last_roll_or_reversal_location (0)
195 , _last_record_location (0)
196 , pending_locate_roll (false)
197 , pending_locate_frame (0)
198 , pending_locate_flush (false)
199 , pending_abort (false)
200 , pending_auto_loop (false)
201 , _butler (new Butler (*this))
202 , _post_transport_work (0)
203 , cumulative_rf_motion (0)
205 , _locations (new Locations (*this))
207 , outbound_mtc_timecode_frame (0)
208 , next_quarter_frame_to_send (-1)
209 , _frames_per_timecode_frame (0)
210 , _frames_per_hour (0)
211 , _timecode_frames_per_hour (0)
212 , last_timecode_valid (false)
213 , last_timecode_when (0)
214 , _send_timecode_update (false)
226 , ltc_timecode_offset (0)
227 , ltc_timecode_negative_offset (false)
228 , midi_control_ui (0)
230 , _all_route_group (new RouteGroup (*this, "all"))
231 , routes (new RouteList)
232 , _adding_routes_in_progress (false)
233 , destructive_index (0)
234 , solo_update_disabled (false)
235 , default_fade_steepness (0)
236 , default_fade_msecs (0)
237 , _total_free_4k_blocks (0)
238 , _total_free_4k_blocks_uncertain (false)
239 , no_questions_about_missing_files (false)
242 , _bundles (new BundleList)
243 , _bundle_xml_node (0)
247 , click_emphasis_data (0)
249 , click_emphasis_length (0)
250 , _clicks_cleared (0)
251 , _play_range (false)
253 , first_file_data_format_reset (true)
254 , first_file_header_format_reset (true)
255 , have_looped (false)
256 , _have_rec_enabled_track (false)
258 , _suspend_timecode_transmission (0)
259 , _speakers (new Speakers)
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 */
530 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
531 Glib::Threads::Mutex::Lock lm (source_lock);
532 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
533 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
534 i->second->drop_references ();
540 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
541 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
546 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
549 delete _mmc; _mmc = 0;
550 delete _midi_ports; _midi_ports = 0;
551 delete _locations; _locations = 0;
553 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
555 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
556 boost_debug_list_ptrs ();
561 Session::setup_ltc ()
565 _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
566 _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
568 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
569 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
572 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
573 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
575 reconnect_ltc_input ();
578 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
579 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
582 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
583 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
585 reconnect_ltc_output ();
588 /* fix up names of LTC ports because we don't want the normal
589 * IO style of NAME/TYPE-{in,out}N
592 _ltc_input->nth (0)->set_name (X_("LTC-in"));
593 _ltc_output->nth (0)->set_name (X_("LTC-out"));
597 Session::setup_click ()
600 _click_io.reset (new ClickIO (*this, X_("Click")));
601 _click_gain.reset (new Amp (*this));
602 _click_gain->activate ();
604 setup_click_state (state_tree->root());
606 setup_click_state (0);
611 Session::setup_click_state (const XMLNode* node)
613 const XMLNode* child = 0;
615 if (node && (child = find_named_node (*node, "Click")) != 0) {
617 /* existing state for Click */
620 if (Stateful::loading_state_version < 3000) {
621 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
623 const XMLNodeList& children (child->children());
624 XMLNodeList::const_iterator i = children.begin();
625 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
627 if (i != children.end()) {
628 c = _click_gain->set_state (**i, Stateful::loading_state_version);
634 _clicking = Config->get_clicking ();
638 error << _("could not setup Click I/O") << endmsg;
645 /* default state for Click: dual-mono to first 2 physical outputs */
648 _engine.get_physical_outputs (DataType::AUDIO, outs);
650 for (uint32_t physport = 0; physport < 2; ++physport) {
651 if (outs.size() > physport) {
652 if (_click_io->add_port (outs[physport], this)) {
653 // relax, even though its an error
658 if (_click_io->n_ports () > ChanCount::ZERO) {
659 _clicking = Config->get_clicking ();
665 Session::setup_bundles ()
667 vector<string> inputs[DataType::num_types];
668 vector<string> outputs[DataType::num_types];
669 for (uint32_t i = 0; i < DataType::num_types; ++i) {
670 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
671 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
674 /* Create a set of Bundle objects that map
675 to the physical I/O currently available. We create both
676 mono and stereo bundles, so that the common cases of mono
677 and stereo tracks get bundles to put in their mixer strip
678 in / out menus. There may be a nicer way of achieving that;
679 it doesn't really scale that well to higher channel counts
682 /* mono output bundles */
684 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
686 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
688 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
689 c->add_channel (_("mono"), DataType::AUDIO);
690 c->set_port (0, outputs[DataType::AUDIO][np]);
695 /* stereo output bundles */
697 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
698 if (np + 1 < outputs[DataType::AUDIO].size()) {
700 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
701 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
702 c->add_channel (_("L"), DataType::AUDIO);
703 c->set_port (0, outputs[DataType::AUDIO][np]);
704 c->add_channel (_("R"), DataType::AUDIO);
705 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
711 /* mono input bundles */
713 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
715 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
717 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
718 c->add_channel (_("mono"), DataType::AUDIO);
719 c->set_port (0, inputs[DataType::AUDIO][np]);
724 /* stereo input bundles */
726 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
727 if (np + 1 < inputs[DataType::AUDIO].size()) {
729 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
731 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
732 c->add_channel (_("L"), DataType::AUDIO);
733 c->set_port (0, inputs[DataType::AUDIO][np]);
734 c->add_channel (_("R"), DataType::AUDIO);
735 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
741 /* MIDI input bundles */
743 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
744 string n = inputs[DataType::MIDI][np];
745 boost::erase_first (n, X_("alsa_pcm:"));
747 boost::shared_ptr<Bundle> c (new Bundle (n, false));
748 c->add_channel ("", DataType::MIDI);
749 c->set_port (0, inputs[DataType::MIDI][np]);
753 /* MIDI output bundles */
755 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
756 string n = outputs[DataType::MIDI][np];
757 boost::erase_first (n, X_("alsa_pcm:"));
759 boost::shared_ptr<Bundle> c (new Bundle (n, true));
760 c->add_channel ("", DataType::MIDI);
761 c->set_port (0, outputs[DataType::MIDI][np]);
768 Session::auto_connect_master_bus ()
770 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
774 /* if requested auto-connect the outputs to the first N physical ports.
777 uint32_t limit = _master_out->n_outputs().n_total();
778 vector<string> outputs[DataType::num_types];
780 for (uint32_t i = 0; i < DataType::num_types; ++i) {
781 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
784 for (uint32_t n = 0; n < limit; ++n) {
785 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
787 if (outputs[p->type()].size() > n) {
788 connect_to = outputs[p->type()][n];
791 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
792 if (_master_out->output()->connect (p, connect_to, this)) {
793 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
802 Session::remove_monitor_section ()
808 /* force reversion to Solo-In-Place */
809 Config->set_solo_control_is_listen_control (false);
811 /* if we are auditioning, cancel it ... this is a workaround
812 to a problem (auditioning does not execute the process graph,
813 which is needed to remove routes when using >1 core for processing)
818 /* Hold process lock while doing this so that we don't hear bits and
819 * pieces of audio as we work on each route.
822 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
824 /* Connect tracks to monitor section. Note that in an
825 existing session, the internal sends will already exist, but we want the
826 routes to notice that they connect to the control out specifically.
830 boost::shared_ptr<RouteList> r = routes.reader ();
831 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
833 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
835 if ((*x)->is_monitor()) {
837 } else if ((*x)->is_master()) {
840 (*x)->remove_aux_or_listen (_monitor_out);
845 remove_route (_monitor_out);
846 auto_connect_master_bus ();
849 auditioner->connect ();
854 Session::add_monitor_section ()
858 if (_monitor_out || !_master_out) {
862 boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
868 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
869 // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
872 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
873 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
874 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
878 add_routes (rl, false, false, false);
880 assert (_monitor_out);
882 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
883 are undefined, at best.
886 uint32_t limit = _monitor_out->n_inputs().n_audio();
890 /* connect the inputs to the master bus outputs. this
891 * represents a separate data feed from the internal sends from
892 * each route. as of jan 2011, it allows the monitor section to
893 * conditionally ignore either the internal sends or the normal
894 * input feed, but we should really find a better way to do
898 _master_out->output()->disconnect (this);
900 for (uint32_t n = 0; n < limit; ++n) {
901 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
902 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
905 string connect_to = o->name();
906 if (_monitor_out->input()->connect (p, connect_to, this)) {
907 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
915 /* if monitor section is not connected, connect it to physical outs
918 if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
920 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
922 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
925 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
927 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
928 Config->get_monitor_bus_preferred_bundle())
934 /* Monitor bus is audio only */
936 vector<string> outputs[DataType::num_types];
938 for (uint32_t i = 0; i < DataType::num_types; ++i) {
939 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
942 uint32_t mod = outputs[DataType::AUDIO].size();
943 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
947 for (uint32_t n = 0; n < limit; ++n) {
949 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
951 if (outputs[DataType::AUDIO].size() > (n % mod)) {
952 connect_to = outputs[DataType::AUDIO][n % mod];
955 if (!connect_to.empty()) {
956 if (_monitor_out->output()->connect (p, connect_to, this)) {
957 error << string_compose (
958 _("cannot connect control output %1 to %2"),
969 /* Hold process lock while doing this so that we don't hear bits and
970 * pieces of audio as we work on each route.
973 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
975 /* Connect tracks to monitor section. Note that in an
976 existing session, the internal sends will already exist, but we want the
977 routes to notice that they connect to the control out specifically.
981 boost::shared_ptr<RouteList> rls = routes.reader ();
983 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
985 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
987 if ((*x)->is_monitor()) {
989 } else if ((*x)->is_master()) {
992 (*x)->enable_monitor_send ();
997 auditioner->connect ();
1002 Session::hookup_io ()
1004 /* stop graph reordering notifications from
1005 causing resorts, etc.
1008 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1012 /* we delay creating the auditioner till now because
1013 it makes its own connections to ports.
1017 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1019 throw failed_constructor ();
1021 a->use_new_diskstream ();
1025 catch (failed_constructor& err) {
1026 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1030 /* load bundles, which we may have postponed earlier on */
1031 if (_bundle_xml_node) {
1032 load_bundles (*_bundle_xml_node);
1033 delete _bundle_xml_node;
1036 /* Tell all IO objects to connect themselves together */
1038 IO::enable_connecting ();
1040 /* Now tell all "floating" ports to connect to whatever
1041 they should be connected to.
1044 AudioEngine::instance()->reconnect_ports ();
1046 /* Anyone who cares about input state, wake up and do something */
1048 IOConnectionsComplete (); /* EMIT SIGNAL */
1050 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1052 /* now handle the whole enchilada as if it was one
1053 graph reorder event.
1058 /* update the full solo state, which can't be
1059 correctly determined on a per-route basis, but
1060 needs the global overview that only the session
1064 update_route_solo_state ();
1068 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1070 boost::shared_ptr<Track> track = wp.lock ();
1075 boost::shared_ptr<Playlist> playlist;
1077 if ((playlist = track->playlist()) != 0) {
1078 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1079 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1080 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1085 Session::record_enabling_legal () const
1087 /* this used to be in here, but survey says.... we don't need to restrict it */
1088 // if (record_status() == Recording) {
1092 if (Config->get_all_safe()) {
1099 Session::set_track_monitor_input_status (bool yn)
1101 boost::shared_ptr<RouteList> rl = routes.reader ();
1102 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1103 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1104 if (tr && tr->record_enabled ()) {
1105 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1106 tr->request_input_monitoring (yn);
1112 Session::auto_punch_start_changed (Location* location)
1114 replace_event (SessionEvent::PunchIn, location->start());
1116 if (get_record_enabled() && config.get_punch_in()) {
1117 /* capture start has been changed, so save new pending state */
1118 save_state ("", true);
1123 Session::auto_punch_end_changed (Location* location)
1125 framepos_t when_to_stop = location->end();
1126 // when_to_stop += _worst_output_latency + _worst_input_latency;
1127 replace_event (SessionEvent::PunchOut, when_to_stop);
1131 Session::auto_punch_changed (Location* location)
1133 framepos_t when_to_stop = location->end();
1135 replace_event (SessionEvent::PunchIn, location->start());
1136 //when_to_stop += _worst_output_latency + _worst_input_latency;
1137 replace_event (SessionEvent::PunchOut, when_to_stop);
1140 /** @param loc A loop location.
1141 * @param pos Filled in with the start time of the required fade-out (in session frames).
1142 * @param length Filled in with the length of the required fade-out.
1145 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1147 pos = max (loc->start(), loc->end() - 64);
1148 length = loc->end() - pos;
1152 Session::auto_loop_changed (Location* location)
1154 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1157 auto_loop_declick_range (location, dcp, dcl);
1158 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1160 if (transport_rolling() && play_loop) {
1163 // if (_transport_frame > location->end()) {
1165 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1166 // relocate to beginning of loop
1167 clear_events (SessionEvent::LocateRoll);
1169 request_locate (location->start(), true);
1172 else if (Config->get_seamless_loop() && !loop_changing) {
1174 // schedule a locate-roll to refill the diskstreams at the
1175 // previous loop end
1176 loop_changing = true;
1178 if (location->end() > last_loopend) {
1179 clear_events (SessionEvent::LocateRoll);
1180 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1187 last_loopend = location->end();
1191 Session::set_auto_punch_location (Location* location)
1195 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1196 punch_connections.drop_connections();
1197 existing->set_auto_punch (false, this);
1198 remove_event (existing->start(), SessionEvent::PunchIn);
1199 clear_events (SessionEvent::PunchOut);
1200 auto_punch_location_changed (0);
1205 if (location == 0) {
1209 if (location->end() <= location->start()) {
1210 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1214 punch_connections.drop_connections ();
1216 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
1217 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
1218 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
1220 location->set_auto_punch (true, this);
1222 auto_punch_changed (location);
1224 auto_punch_location_changed (location);
1228 Session::set_auto_loop_location (Location* location)
1232 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1233 loop_connections.drop_connections ();
1234 existing->set_auto_loop (false, this);
1235 remove_event (existing->end(), SessionEvent::AutoLoop);
1238 auto_loop_declick_range (existing, dcp, dcl);
1239 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1240 auto_loop_location_changed (0);
1245 if (location == 0) {
1249 if (location->end() <= location->start()) {
1250 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1254 last_loopend = location->end();
1256 loop_connections.drop_connections ();
1258 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1259 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1260 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1262 location->set_auto_loop (true, this);
1264 /* take care of our stuff first */
1266 auto_loop_changed (location);
1268 /* now tell everyone else */
1270 auto_loop_location_changed (location);
1274 Session::locations_added (Location *)
1280 Session::locations_changed ()
1282 _locations->apply (*this, &Session::handle_locations_changed);
1286 Session::handle_locations_changed (Locations::LocationList& locations)
1288 Locations::LocationList::iterator i;
1290 bool set_loop = false;
1291 bool set_punch = false;
1293 for (i = locations.begin(); i != locations.end(); ++i) {
1297 if (location->is_auto_punch()) {
1298 set_auto_punch_location (location);
1301 if (location->is_auto_loop()) {
1302 set_auto_loop_location (location);
1306 if (location->is_session_range()) {
1307 _session_range_location = location;
1312 set_auto_loop_location (0);
1315 set_auto_punch_location (0);
1322 Session::enable_record ()
1324 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1325 /* no recording at anything except normal speed */
1330 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1332 if (rs == Recording) {
1336 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1338 _last_record_location = _transport_frame;
1339 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1341 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1342 set_track_monitor_input_status (true);
1345 RecordStateChanged ();
1352 Session::disable_record (bool rt_context, bool force)
1356 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1358 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1359 g_atomic_int_set (&_record_status, Disabled);
1360 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1362 if (rs == Recording) {
1363 g_atomic_int_set (&_record_status, Enabled);
1367 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1368 set_track_monitor_input_status (false);
1371 RecordStateChanged (); /* emit signal */
1374 remove_pending_capture_state ();
1380 Session::step_back_from_record ()
1382 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1384 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1385 set_track_monitor_input_status (false);
1388 RecordStateChanged (); /* emit signal */
1393 Session::maybe_enable_record ()
1395 if (_step_editors > 0) {
1399 g_atomic_int_set (&_record_status, Enabled);
1401 /* This function is currently called from somewhere other than an RT thread.
1402 This save_state() call therefore doesn't impact anything. Doing it here
1403 means that we save pending state of which sources the next record will use,
1404 which gives us some chance of recovering from a crash during the record.
1407 save_state ("", true);
1409 if (_transport_speed) {
1410 if (!config.get_punch_in()) {
1414 _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1415 RecordStateChanged (); /* EMIT SIGNAL */
1422 Session::audible_frame () const
1428 /* the first of these two possible settings for "offset"
1429 mean that the audible frame is stationary until
1430 audio emerges from the latency compensation
1433 the second means that the audible frame is stationary
1434 until audio would emerge from a physical port
1435 in the absence of any plugin latency compensation
1438 offset = worst_playback_latency ();
1440 if (offset > current_block_size) {
1441 offset -= current_block_size;
1443 /* XXX is this correct? if we have no external
1444 physical connections and everything is internal
1445 then surely this is zero? still, how
1446 likely is that anyway?
1448 offset = current_block_size;
1451 if (synced_to_engine()) {
1452 tf = _engine.transport_frame();
1454 tf = _transport_frame;
1459 if (!non_realtime_work_pending()) {
1463 /* Check to see if we have passed the first guaranteed
1464 audible frame past our last start position. if not,
1465 return that last start point because in terms
1466 of audible frames, we have not moved yet.
1468 `Start position' in this context means the time we last
1469 either started, located, or changed transport direction.
1472 if (_transport_speed > 0.0f) {
1474 if (!play_loop || !have_looped) {
1475 if (tf < _last_roll_or_reversal_location + offset) {
1476 return _last_roll_or_reversal_location;
1484 } else if (_transport_speed < 0.0f) {
1486 /* XXX wot? no backward looping? */
1488 if (tf > _last_roll_or_reversal_location - offset) {
1489 return _last_roll_or_reversal_location;
1501 Session::set_frame_rate (framecnt_t frames_per_second)
1503 /** \fn void Session::set_frame_size(framecnt_t)
1504 the AudioEngine object that calls this guarantees
1505 that it will not be called while we are also in
1506 ::process(). Its fine to do things that block
1510 _base_frame_rate = frames_per_second;
1511 _nominal_frame_rate = frames_per_second;
1517 // XXX we need some equivalent to this, somehow
1518 // SndFileSource::setup_standard_crossfades (frames_per_second);
1522 /* XXX need to reset/reinstantiate all LADSPA plugins */
1526 Session::set_block_size (pframes_t nframes)
1528 /* the AudioEngine guarantees
1529 that it will not be called while we are also in
1530 ::process(). It is therefore fine to do things that block
1535 current_block_size = nframes;
1539 boost::shared_ptr<RouteList> r = routes.reader ();
1541 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1542 (*i)->set_block_size (nframes);
1545 boost::shared_ptr<RouteList> rl = routes.reader ();
1546 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1547 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1549 tr->set_block_size (nframes);
1553 set_worst_io_latencies ();
1559 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1561 boost::shared_ptr<Route> r2;
1563 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1564 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1568 /* make a copy of the existing list of routes that feed r1 */
1570 Route::FedBy existing (r1->fed_by());
1572 /* for each route that feeds r1, recurse, marking it as feeding
1576 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1577 if (!(r2 = i->r.lock ())) {
1578 /* (*i) went away, ignore it */
1582 /* r2 is a route that feeds r1 which somehow feeds base. mark
1583 base as being fed by r2
1586 rbase->add_fed_by (r2, i->sends_only);
1590 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1594 if (r1->feeds (r2) && r2->feeds (r1)) {
1598 /* now recurse, so that we can mark base as being fed by
1599 all routes that feed r2
1602 trace_terminal (r2, rbase);
1609 Session::resort_routes ()
1611 /* don't do anything here with signals emitted
1612 by Routes during initial setup or while we
1613 are being destroyed.
1616 if (_state_of_the_state & (InitialConnecting | Deletion)) {
1621 RCUWriter<RouteList> writer (routes);
1622 boost::shared_ptr<RouteList> r = writer.get_copy ();
1623 resort_routes_using (r);
1624 /* writer goes out of scope and forces update */
1628 boost::shared_ptr<RouteList> rl = routes.reader ();
1629 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1630 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1632 const Route::FedBy& fb ((*i)->fed_by());
1634 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1635 boost::shared_ptr<Route> sf = f->r.lock();
1637 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1645 /** This is called whenever we need to rebuild the graph of how we will process
1647 * @param r List of routes, in any order.
1651 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1653 /* We are going to build a directed graph of our routes;
1654 this is where the edges of that graph are put.
1659 /* Go through all routes doing two things:
1661 * 1. Collect the edges of the route graph. Each of these edges
1662 * is a pair of routes, one of which directly feeds the other
1663 * either by a JACK connection or by an internal send.
1665 * 2. Begin the process of making routes aware of which other
1666 * routes directly or indirectly feed them. This information
1667 * is used by the solo code.
1670 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1672 /* Clear out the route's list of direct or indirect feeds */
1673 (*i)->clear_fed_by ();
1675 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1677 bool via_sends_only;
1679 /* See if this *j feeds *i according to the current state of the JACK
1680 connections and internal sends.
1682 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1683 /* add the edge to the graph (part #1) */
1684 edges.add (*j, *i, via_sends_only);
1685 /* tell the route (for part #2) */
1686 (*i)->add_fed_by (*j, via_sends_only);
1691 /* Attempt a topological sort of the route graph */
1692 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1694 if (sorted_routes) {
1695 /* We got a satisfactory topological sort, so there is no feedback;
1698 Note: the process graph rechain does not require a
1699 topologically-sorted list, but hey ho.
1701 if (_process_graph) {
1702 _process_graph->rechain (sorted_routes, edges);
1705 _current_route_graph = edges;
1707 /* Complete the building of the routes' lists of what directly
1708 or indirectly feeds them.
1710 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1711 trace_terminal (*i, *i);
1714 *r = *sorted_routes;
1717 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1718 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1719 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1720 (*i)->name(), (*i)->order_key ()));
1724 SuccessfulGraphSort (); /* EMIT SIGNAL */
1727 /* The topological sort failed, so we have a problem. Tell everyone
1728 and stick to the old graph; this will continue to be processed, so
1729 until the feedback is fixed, what is played back will not quite
1730 reflect what is actually connected. Note also that we do not
1731 do trace_terminal here, as it would fail due to an endless recursion,
1732 so the solo code will think that everything is still connected
1736 FeedbackDetected (); /* EMIT SIGNAL */
1741 /** Find a route name starting with \a base, maybe followed by the
1742 * lowest \a id. \a id will always be added if \a definitely_add_number
1743 * is true on entry; otherwise it will only be added if required
1744 * to make the name unique.
1746 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1747 * The available route name with the lowest ID will be used, and \a id
1748 * will be set to the ID.
1750 * \return false if a route name could not be found, and \a track_name
1751 * and \a id do not reflect a free route name.
1754 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1756 if (!definitely_add_number && route_by_name (base) == 0) {
1757 /* juse use the base */
1758 snprintf (name, name_len, "%s", base.c_str());
1763 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1765 if (route_by_name (name) == 0) {
1771 } while (id < (UINT_MAX-1));
1776 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1778 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1780 in = ChanCount::ZERO;
1781 out = ChanCount::ZERO;
1783 boost::shared_ptr<RouteList> r = routes.reader ();
1785 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1786 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1787 if (tr && !tr->is_auditioner()) {
1788 in += tr->n_inputs();
1789 out += tr->n_outputs();
1794 /** Caller must not hold process lock
1795 * @param name_template string to use for the start of the name, or "" to use "MIDI".
1796 * @param instrument plugin info for the instrument to insert pre-fader, if any
1798 list<boost::shared_ptr<MidiTrack> >
1799 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1800 TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1802 char track_name[32];
1803 uint32_t track_id = 0;
1805 RouteList new_routes;
1806 list<boost::shared_ptr<MidiTrack> > ret;
1808 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1811 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1812 error << "cannot find name for new midi track" << endmsg;
1816 boost::shared_ptr<MidiTrack> track;
1819 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1821 if (track->init ()) {
1825 track->use_new_diskstream();
1827 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1828 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1831 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1832 if (track->input()->ensure_io (input, false, this)) {
1833 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1837 if (track->output()->ensure_io (output, false, this)) {
1838 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1843 track->non_realtime_input_change();
1846 route_group->add (track);
1849 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1851 if (Config->get_remote_model() == UserOrdered) {
1852 track->set_remote_control_id (next_control_id());
1855 new_routes.push_back (track);
1856 ret.push_back (track);
1859 catch (failed_constructor &err) {
1860 error << _("Session: could not create new midi track.") << endmsg;
1864 catch (AudioEngine::PortRegistrationFailure& pfe) {
1866 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;
1874 if (!new_routes.empty()) {
1875 add_routes (new_routes, true, true, true);
1878 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1879 PluginPtr plugin = instrument->load (*this);
1880 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1881 (*r)->add_processor (p, PreFader);
1891 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1893 boost::shared_ptr<Route> midi_track (wmt.lock());
1899 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1901 if (change.after.n_audio() <= change.before.n_audio()) {
1905 /* new audio ports: make sure the audio goes somewhere useful,
1906 unless the user has no-auto-connect selected.
1908 The existing ChanCounts don't matter for this call as they are only
1909 to do with matching input and output indices, and we are only changing
1915 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1919 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1920 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1921 * @param output_start As \a input_start, but for outputs.
1924 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1925 bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1927 if (!IO::connecting_legal) {
1931 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1937 /* If both inputs and outputs are auto-connected to physical ports,
1938 use the max of input and output offsets to ensure auto-connected
1939 port numbers always match up (e.g. the first audio input and the
1940 first audio output of the route will have the same physical
1941 port number). Otherwise just use the lowest input or output
1945 DEBUG_TRACE (DEBUG::Graph,
1946 string_compose("Auto-connect: existing in = %1 out = %2\n",
1947 existing_inputs, existing_outputs));
1949 const bool in_out_physical =
1950 (Config->get_input_auto_connect() & AutoConnectPhysical)
1951 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1954 const ChanCount in_offset = in_out_physical
1955 ? ChanCount::max(existing_inputs, existing_outputs)
1958 const ChanCount out_offset = in_out_physical
1959 ? ChanCount::max(existing_inputs, existing_outputs)
1962 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1963 vector<string> physinputs;
1964 vector<string> physoutputs;
1966 _engine.get_physical_outputs (*t, physoutputs);
1967 _engine.get_physical_inputs (*t, physinputs);
1969 if (!physinputs.empty() && connect_inputs) {
1970 uint32_t nphysical_in = physinputs.size();
1972 DEBUG_TRACE (DEBUG::Graph,
1973 string_compose("There are %1 physical inputs of type %2\n",
1976 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1979 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1980 DEBUG_TRACE (DEBUG::Graph,
1981 string_compose("Get index %1 + %2 % %3 = %4\n",
1982 in_offset.get(*t), i, nphysical_in,
1983 (in_offset.get(*t) + i) % nphysical_in));
1984 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1987 DEBUG_TRACE (DEBUG::Graph,
1988 string_compose("Connect route %1 IN to %2\n",
1989 route->name(), port));
1991 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1995 ChanCount one_added (*t, 1);
1996 existing_inputs += one_added;
2000 if (!physoutputs.empty()) {
2001 uint32_t nphysical_out = physoutputs.size();
2002 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
2005 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
2006 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
2007 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
2008 /* master bus is audio only */
2009 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
2010 port = _master_out->input()->ports().port(*t,
2011 i % _master_out->input()->n_ports().get(*t))->name();
2015 DEBUG_TRACE (DEBUG::Graph,
2016 string_compose("Connect route %1 OUT to %2\n",
2017 route->name(), port));
2019 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2023 ChanCount one_added (*t, 1);
2024 existing_outputs += one_added;
2030 /** Caller must not hold process lock
2031 * @param name_template string to use for the start of the name, or "" to use "Audio".
2033 list< boost::shared_ptr<AudioTrack> >
2034 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2035 uint32_t how_many, string name_template)
2037 char track_name[32];
2038 uint32_t track_id = 0;
2040 RouteList new_routes;
2041 list<boost::shared_ptr<AudioTrack> > ret;
2043 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
2046 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2047 error << "cannot find name for new audio track" << endmsg;
2051 boost::shared_ptr<AudioTrack> track;
2054 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2056 if (track->init ()) {
2060 track->use_new_diskstream();
2062 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2063 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2066 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2068 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2069 error << string_compose (
2070 _("cannot configure %1 in/%2 out configuration for new audio track"),
2071 input_channels, output_channels)
2076 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2077 error << string_compose (
2078 _("cannot configure %1 in/%2 out configuration for new audio track"),
2079 input_channels, output_channels)
2086 route_group->add (track);
2089 track->non_realtime_input_change();
2091 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2092 if (Config->get_remote_model() == UserOrdered) {
2093 track->set_remote_control_id (next_control_id());
2096 new_routes.push_back (track);
2097 ret.push_back (track);
2100 catch (failed_constructor &err) {
2101 error << _("Session: could not create new audio track.") << endmsg;
2105 catch (AudioEngine::PortRegistrationFailure& pfe) {
2107 error << pfe.what() << endmsg;
2115 if (!new_routes.empty()) {
2116 add_routes (new_routes, true, true, true);
2122 /** Caller must not hold process lock.
2123 * @param name_template string to use for the start of the name, or "" to use "Bus".
2126 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2129 uint32_t bus_id = 0;
2133 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2136 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2137 error << "cannot find name for new audio bus" << endmsg;
2142 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2148 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2149 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2152 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2154 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2155 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2156 input_channels, output_channels)
2162 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2163 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2164 input_channels, output_channels)
2171 route_group->add (bus);
2173 if (Config->get_remote_model() == UserOrdered) {
2174 bus->set_remote_control_id (next_control_id());
2177 bus->add_internal_return ();
2179 ret.push_back (bus);
2185 catch (failed_constructor &err) {
2186 error << _("Session: could not create new audio route.") << endmsg;
2190 catch (AudioEngine::PortRegistrationFailure& pfe) {
2191 error << pfe.what() << endmsg;
2201 add_routes (ret, false, true, true); // autoconnect outputs only
2209 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2212 uint32_t control_id;
2214 uint32_t number = 0;
2215 const uint32_t being_added = how_many;
2217 if (!tree.read (template_path.c_str())) {
2221 XMLNode* node = tree.root();
2223 IO::disable_connecting ();
2225 control_id = next_control_id ();
2229 XMLNode node_copy (*node);
2231 /* Remove IDs of everything so that new ones are used */
2232 node_copy.remove_property_recursively (X_("id"));
2237 if (!name_base.empty()) {
2239 /* if we're adding more than one routes, force
2240 * all the names of the new routes to be
2241 * numbered, via the final parameter.
2244 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2245 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2251 string const route_name = node_copy.property(X_("name"))->value ();
2253 /* generate a new name by adding a number to the end of the template name */
2254 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2255 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2260 /* set this name in the XML description that we are about to use */
2261 Route::set_name_in_state (node_copy, name);
2263 /* trim bitslots from listen sends so that new ones are used */
2264 XMLNodeList children = node_copy.children ();
2265 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2266 if ((*i)->name() == X_("Processor")) {
2267 XMLProperty* role = (*i)->property (X_("role"));
2268 if (role && role->value() == X_("Listen")) {
2269 (*i)->remove_property (X_("bitslot"));
2274 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2277 error << _("Session: cannot create track/bus from template description") << endmsg;
2281 if (boost::dynamic_pointer_cast<Track>(route)) {
2282 /* force input/output change signals so that the new diskstream
2283 picks up the configuration of the route. During session
2284 loading this normally happens in a different way.
2287 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2289 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2290 change.after = route->input()->n_ports();
2291 route->input()->changed (change, this);
2292 change.after = route->output()->n_ports();
2293 route->output()->changed (change, this);
2296 route->set_remote_control_id (control_id);
2299 ret.push_back (route);
2302 catch (failed_constructor &err) {
2303 error << _("Session: could not create new route from template") << endmsg;
2307 catch (AudioEngine::PortRegistrationFailure& pfe) {
2308 error << pfe.what() << endmsg;
2317 add_routes (ret, true, true, true);
2318 IO::enable_connecting ();
2325 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2328 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2329 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2332 error << _("Adding new tracks/busses failed") << endmsg;
2337 update_latency (true);
2338 update_latency (false);
2343 save_state (_current_snapshot_name);
2346 RouteAdded (new_routes); /* EMIT SIGNAL */
2350 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2352 ChanCount existing_inputs;
2353 ChanCount existing_outputs;
2354 uint32_t order = next_control_id();
2356 if (_order_hint != 0) {
2357 order = _order_hint;
2361 count_existing_track_channels (existing_inputs, existing_outputs);
2364 RCUWriter<RouteList> writer (routes);
2365 boost::shared_ptr<RouteList> r = writer.get_copy ();
2366 r->insert (r->end(), new_routes.begin(), new_routes.end());
2368 /* if there is no control out and we're not in the middle of loading,
2369 resort the graph here. if there is a control out, we will resort
2370 toward the end of this method. if we are in the middle of loading,
2371 we will resort when done.
2374 if (!_monitor_out && IO::connecting_legal) {
2375 resort_routes_using (r);
2379 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2381 boost::weak_ptr<Route> wpr (*x);
2382 boost::shared_ptr<Route> r (*x);
2384 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2385 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2386 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2387 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2388 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2389 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2391 if (r->is_master()) {
2395 if (r->is_monitor()) {
2399 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2401 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2402 track_playlist_changed (boost::weak_ptr<Track> (tr));
2403 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2405 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2407 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2408 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2413 if (input_auto_connect || output_auto_connect) {
2414 auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2417 /* order keys are a GUI responsibility but we need to set up
2418 reasonable defaults because they also affect the remote control
2419 ID in most situations.
2422 if (!r->has_order_key ()) {
2423 if (r->is_auditioner()) {
2424 /* use an arbitrarily high value */
2425 r->set_order_key (UINT_MAX);
2427 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2428 r->set_order_key (order);
2436 if (_monitor_out && IO::connecting_legal) {
2437 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2439 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2440 if ((*x)->is_monitor()) {
2442 } else if ((*x)->is_master()) {
2445 (*x)->enable_monitor_send ();
2452 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2454 boost::shared_ptr<RouteList> r = routes.reader ();
2455 boost::shared_ptr<Send> s;
2457 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2458 if ((s = (*i)->internal_send_for (dest)) != 0) {
2459 s->amp()->gain_control()->set_value (0.0);
2465 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2467 boost::shared_ptr<RouteList> r = routes.reader ();
2468 boost::shared_ptr<Send> s;
2470 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2471 if ((s = (*i)->internal_send_for (dest)) != 0) {
2472 s->amp()->gain_control()->set_value (1.0);
2478 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2480 boost::shared_ptr<RouteList> r = routes.reader ();
2481 boost::shared_ptr<Send> s;
2483 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2484 if ((s = (*i)->internal_send_for (dest)) != 0) {
2485 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2490 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2492 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2494 boost::shared_ptr<RouteList> r = routes.reader ();
2495 boost::shared_ptr<RouteList> t (new RouteList);
2497 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2498 /* no MIDI sends because there are no MIDI busses yet */
2499 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2504 add_internal_sends (dest, p, t);
2508 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2510 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2511 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2516 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2518 add_internal_send (dest, sender->before_processor_for_index (index), sender);
2522 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2524 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2528 if (!dest->internal_return()) {
2529 dest->add_internal_return ();
2532 sender->add_aux_send (dest, before);
2538 Session::remove_route (boost::shared_ptr<Route> route)
2540 if (route == _master_out) {
2544 route->set_solo (false, this);
2547 RCUWriter<RouteList> writer (routes);
2548 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2552 /* deleting the master out seems like a dumb
2553 idea, but its more of a UI policy issue
2557 if (route == _master_out) {
2558 _master_out = boost::shared_ptr<Route> ();
2561 if (route == _monitor_out) {
2562 _monitor_out.reset ();
2565 /* writer goes out of scope, forces route list update */
2568 update_route_solo_state ();
2570 // We need to disconnect the route's inputs and outputs
2572 route->input()->disconnect (0);
2573 route->output()->disconnect (0);
2575 /* if the route had internal sends sending to it, remove them */
2576 if (route->internal_return()) {
2578 boost::shared_ptr<RouteList> r = routes.reader ();
2579 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2580 boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2582 (*i)->remove_processor (s);
2587 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2588 if (mt && mt->step_editing()) {
2589 if (_step_editors > 0) {
2594 update_latency_compensation ();
2597 /* Re-sort routes to remove the graph's current references to the one that is
2598 * going away, then flush old references out of the graph.
2602 if (_process_graph) {
2603 _process_graph->clear_other_chain ();
2606 /* get rid of it from the dead wood collection in the route list manager */
2608 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2612 /* try to cause everyone to drop their references */
2614 route->drop_references ();
2616 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2618 /* save the new state of the world */
2620 if (save_state (_current_snapshot_name)) {
2621 save_history (_current_snapshot_name);
2626 Session::route_mute_changed (void* /*src*/)
2632 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2634 boost::shared_ptr<Route> route = wpr.lock();
2636 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2640 if (route->listening_via_monitor ()) {
2642 if (Config->get_exclusive_solo()) {
2643 /* new listen: disable all other listen */
2644 boost::shared_ptr<RouteList> r = routes.reader ();
2645 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2646 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
2649 (*i)->set_listen (false, this);
2655 } else if (_listen_cnt > 0) {
2660 update_route_solo_state ();
2663 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2665 boost::shared_ptr<Route> route = wpr.lock ();
2668 /* should not happen */
2669 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2673 bool send_changed = false;
2675 if (route->solo_isolated()) {
2676 if (_solo_isolated_cnt == 0) {
2677 send_changed = true;
2679 _solo_isolated_cnt++;
2680 } else if (_solo_isolated_cnt > 0) {
2681 _solo_isolated_cnt--;
2682 if (_solo_isolated_cnt == 0) {
2683 send_changed = true;
2688 IsolatedChanged (); /* EMIT SIGNAL */
2693 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2695 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2697 if (!self_solo_change) {
2698 // session doesn't care about changes to soloed-by-others
2702 if (solo_update_disabled) {
2704 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2708 boost::shared_ptr<Route> route = wpr.lock ();
2711 boost::shared_ptr<RouteList> r = routes.reader ();
2714 if (route->self_soloed()) {
2720 RouteGroup* rg = route->route_group ();
2721 bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2723 if (delta == 1 && Config->get_exclusive_solo()) {
2725 /* new solo: disable all other solos, but not the group if its solo-enabled */
2727 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2728 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2729 (leave_group_alone && ((*i)->route_group() == rg))) {
2732 (*i)->set_solo (false, this);
2736 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2738 solo_update_disabled = true;
2740 RouteList uninvolved;
2742 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2744 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2745 bool via_sends_only;
2746 bool in_signal_flow;
2748 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2749 (leave_group_alone && ((*i)->route_group() == rg))) {
2753 in_signal_flow = false;
2755 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2757 if ((*i)->feeds (route, &via_sends_only)) {
2758 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2759 if (!via_sends_only) {
2760 if (!route->soloed_by_others_upstream()) {
2761 (*i)->mod_solo_by_others_downstream (delta);
2764 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2766 in_signal_flow = true;
2768 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2771 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2773 if (route->feeds (*i, &via_sends_only)) {
2774 /* propagate solo upstream only if routing other than
2775 sends is involved, but do consider the other route
2776 (*i) to be part of the signal flow even if only
2779 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2783 route->soloed_by_others_downstream(),
2784 route->soloed_by_others_upstream()));
2785 if (!via_sends_only) {
2786 if (!route->soloed_by_others_downstream()) {
2787 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2788 (*i)->mod_solo_by_others_upstream (delta);
2790 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2793 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2795 in_signal_flow = true;
2797 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2800 if (!in_signal_flow) {
2801 uninvolved.push_back (*i);
2805 solo_update_disabled = false;
2806 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2808 update_route_solo_state (r);
2810 /* now notify that the mute state of the routes not involved in the signal
2811 pathway of the just-solo-changed route may have altered.
2814 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2815 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2816 (*i)->mute_changed (this);
2819 SoloChanged (); /* EMIT SIGNAL */
2824 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2826 /* now figure out if anything that matters is soloed (or is "listening")*/
2828 bool something_soloed = false;
2829 uint32_t listeners = 0;
2830 uint32_t isolated = 0;
2833 r = routes.reader();
2836 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2837 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
2838 something_soloed = true;
2841 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
2842 if (Config->get_solo_control_is_listen_control()) {
2845 (*i)->set_listen (false, this);
2849 if ((*i)->solo_isolated()) {
2854 if (something_soloed != _non_soloed_outs_muted) {
2855 _non_soloed_outs_muted = something_soloed;
2856 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2859 _listen_cnt = listeners;
2861 if (isolated != _solo_isolated_cnt) {
2862 _solo_isolated_cnt = isolated;
2863 IsolatedChanged (); /* EMIT SIGNAL */
2866 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2867 something_soloed, listeners, isolated));
2870 boost::shared_ptr<RouteList>
2871 Session::get_routes_with_internal_returns() const
2873 boost::shared_ptr<RouteList> r = routes.reader ();
2874 boost::shared_ptr<RouteList> rl (new RouteList);
2876 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2877 if ((*i)->internal_return ()) {
2885 Session::io_name_is_legal (const std::string& name)
2887 boost::shared_ptr<RouteList> r = routes.reader ();
2889 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2890 if ((*i)->name() == name) {
2894 if ((*i)->has_io_processor_named (name)) {
2903 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2906 vector<string> connections;
2908 /* if we are passed only a single route and we're not told to turn
2909 * others off, then just do the simple thing.
2912 if (flip_others == false && rl->size() == 1) {
2913 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2915 mt->set_input_active (onoff);
2920 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2922 PortSet& ps ((*rt)->input()->ports());
2924 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2925 p->get_connections (connections);
2928 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2929 routes_using_input_from (*s, rl2);
2932 /* scan all relevant routes to see if others are on or off */
2934 bool others_are_already_on = false;
2936 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2938 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2944 if ((*r) != (*rt)) {
2945 if (mt->input_active()) {
2946 others_are_already_on = true;
2949 /* this one needs changing */
2950 mt->set_input_active (onoff);
2956 /* globally reverse other routes */
2958 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2959 if ((*r) != (*rt)) {
2960 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2962 mt->set_input_active (!others_are_already_on);
2971 Session::routes_using_input_from (const string& str, RouteList& rl)
2973 boost::shared_ptr<RouteList> r = routes.reader();
2975 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2976 if ((*i)->input()->connected_to (str)) {
2982 boost::shared_ptr<Route>
2983 Session::route_by_name (string name)
2985 boost::shared_ptr<RouteList> r = routes.reader ();
2987 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2988 if ((*i)->name() == name) {
2993 return boost::shared_ptr<Route> ((Route*) 0);
2996 boost::shared_ptr<Route>
2997 Session::route_by_id (PBD::ID id)
2999 boost::shared_ptr<RouteList> r = routes.reader ();
3001 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3002 if ((*i)->id() == id) {
3007 return boost::shared_ptr<Route> ((Route*) 0);
3010 boost::shared_ptr<Track>
3011 Session::track_by_diskstream_id (PBD::ID id)
3013 boost::shared_ptr<RouteList> r = routes.reader ();
3015 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3016 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3017 if (t && t->using_diskstream_id (id)) {
3022 return boost::shared_ptr<Track> ();
3025 boost::shared_ptr<Route>
3026 Session::route_by_remote_id (uint32_t id)
3028 boost::shared_ptr<RouteList> r = routes.reader ();
3030 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3031 if ((*i)->remote_control_id() == id) {
3036 return boost::shared_ptr<Route> ((Route*) 0);
3040 Session::playlist_region_added (boost::weak_ptr<Region> w)
3042 boost::shared_ptr<Region> r = w.lock ();
3047 /* These are the operations that are currently in progress... */
3048 list<GQuark> curr = _current_trans_quarks;
3051 /* ...and these are the operations during which we want to update
3052 the session range location markers.
3055 ops.push_back (Operations::capture);
3056 ops.push_back (Operations::paste);
3057 ops.push_back (Operations::duplicate_region);
3058 ops.push_back (Operations::insert_file);
3059 ops.push_back (Operations::insert_region);
3060 ops.push_back (Operations::drag_region_brush);
3061 ops.push_back (Operations::region_drag);
3062 ops.push_back (Operations::selection_grab);
3063 ops.push_back (Operations::region_fill);
3064 ops.push_back (Operations::fill_selection);
3065 ops.push_back (Operations::create_region);
3066 ops.push_back (Operations::region_copy);
3067 ops.push_back (Operations::fixed_time_region_copy);
3070 /* See if any of the current operations match the ones that we want */
3072 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3074 /* If so, update the session range markers */
3076 maybe_update_session_range (r->position (), r->last_frame ());
3080 /** Update the session range markers if a is before the current start or
3081 * b is after the current end.
3084 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3086 if (_state_of_the_state & Loading) {
3090 if (_session_range_location == 0) {
3092 add_session_range_location (a, b);
3096 if (a < _session_range_location->start()) {
3097 _session_range_location->set_start (a);
3100 if (b > _session_range_location->end()) {
3101 _session_range_location->set_end (b);
3107 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3109 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3110 maybe_update_session_range (i->to, i->to + i->length);
3115 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3117 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3118 maybe_update_session_range (i->from, i->to);
3122 /* Region management */
3124 boost::shared_ptr<Region>
3125 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3127 const RegionFactory::RegionMap& regions (RegionFactory::regions());
3128 RegionFactory::RegionMap::const_iterator i;
3129 boost::shared_ptr<Region> region;
3131 Glib::Threads::Mutex::Lock lm (region_lock);
3133 for (i = regions.begin(); i != regions.end(); ++i) {
3137 if (region->whole_file()) {
3139 if (child->source_equivalent (region)) {
3145 return boost::shared_ptr<Region> ();
3149 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3151 set<boost::shared_ptr<Region> > relevant_regions;
3153 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3154 RegionFactory::get_regions_using_source (*s, relevant_regions);
3157 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3158 set<boost::shared_ptr<Region> >::iterator tmp;
3163 playlists->destroy_region (*r);
3164 RegionFactory::map_remove (*r);
3166 (*r)->drop_sources ();
3167 (*r)->drop_references ();
3169 relevant_regions.erase (r);
3174 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3177 Glib::Threads::Mutex::Lock ls (source_lock);
3178 /* remove from the main source list */
3179 sources.erase ((*s)->id());
3182 (*s)->mark_for_remove ();
3183 (*s)->drop_references ();
3192 Session::remove_last_capture ()
3194 list<boost::shared_ptr<Source> > srcs;
3196 boost::shared_ptr<RouteList> rl = routes.reader ();
3197 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3198 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3203 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3206 srcs.insert (srcs.end(), l.begin(), l.end());
3211 destroy_sources (srcs);
3213 save_state (_current_snapshot_name);
3218 /* Source Management */
3221 Session::add_source (boost::shared_ptr<Source> source)
3223 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3224 pair<SourceMap::iterator,bool> result;
3226 entry.first = source->id();
3227 entry.second = source;
3230 Glib::Threads::Mutex::Lock lm (source_lock);
3231 result = sources.insert (entry);
3234 if (result.second) {
3236 /* yay, new source */
3238 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3241 if (!fs->within_session()) {
3242 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3248 boost::shared_ptr<AudioFileSource> afs;
3250 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3251 if (Config->get_auto_analyse_audio()) {
3252 Analyser::queue_source_for_analysis (source, false);
3256 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3261 Session::remove_source (boost::weak_ptr<Source> src)
3263 if (_state_of_the_state & Deletion) {
3267 SourceMap::iterator i;
3268 boost::shared_ptr<Source> source = src.lock();
3275 Glib::Threads::Mutex::Lock lm (source_lock);
3277 if ((i = sources.find (source->id())) != sources.end()) {
3282 if (!(_state_of_the_state & InCleanup)) {
3284 /* save state so we don't end up with a session file
3285 referring to non-existent sources.
3288 save_state (_current_snapshot_name);
3292 boost::shared_ptr<Source>
3293 Session::source_by_id (const PBD::ID& id)
3295 Glib::Threads::Mutex::Lock lm (source_lock);
3296 SourceMap::iterator i;
3297 boost::shared_ptr<Source> source;
3299 if ((i = sources.find (id)) != sources.end()) {
3306 boost::shared_ptr<Source>
3307 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3309 Glib::Threads::Mutex::Lock lm (source_lock);
3311 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3312 boost::shared_ptr<AudioFileSource> afs
3313 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3315 if (afs && afs->path() == path && chn == afs->channel()) {
3319 return boost::shared_ptr<Source>();
3323 Session::count_sources_by_origin (const string& path)
3326 Glib::Threads::Mutex::Lock lm (source_lock);
3328 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3329 boost::shared_ptr<FileSource> fs
3330 = boost::dynamic_pointer_cast<FileSource>(i->second);
3332 if (fs && fs->origin() == path) {
3342 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3345 string old_basename = PBD::basename_nosuffix (oldname);
3346 string new_legalized = legalize_for_path (newname);
3348 /* note: we know (or assume) the old path is already valid */
3352 /* destructive file sources have a name of the form:
3354 /path/to/Tnnnn-NAME(%[LR])?.wav
3356 the task here is to replace NAME with the new name.
3361 string::size_type dash;
3363 dir = Glib::path_get_dirname (path);
3364 path = Glib::path_get_basename (path);
3366 /* '-' is not a legal character for the NAME part of the path */
3368 if ((dash = path.find_last_of ('-')) == string::npos) {
3372 prefix = path.substr (0, dash);
3376 path += new_legalized;
3377 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3378 path = Glib::build_filename (dir, path);
3382 /* non-destructive file sources have a name of the form:
3384 /path/to/NAME-nnnnn(%[LR])?.ext
3386 the task here is to replace NAME with the new name.
3391 string::size_type dash;
3392 string::size_type postfix;
3394 dir = Glib::path_get_dirname (path);
3395 path = Glib::path_get_basename (path);
3397 /* '-' is not a legal character for the NAME part of the path */
3399 if ((dash = path.find_last_of ('-')) == string::npos) {
3403 suffix = path.substr (dash+1);
3405 // Suffix is now everything after the dash. Now we need to eliminate
3406 // the nnnnn part, which is done by either finding a '%' or a '.'
3408 postfix = suffix.find_last_of ("%");
3409 if (postfix == string::npos) {
3410 postfix = suffix.find_last_of ('.');
3413 if (postfix != string::npos) {
3414 suffix = suffix.substr (postfix);
3416 error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3420 const uint32_t limit = 10000;
3421 char buf[PATH_MAX+1];
3423 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3425 snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3427 if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3428 path = Glib::build_filename (dir, buf);
3436 fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3445 /** Return the full path (in some session directory) for a new within-session source.
3446 * \a name must be a session-unique name that does not contain slashes
3447 * (e.g. as returned by new_*_source_name)
3450 Session::new_source_path_from_name (DataType type, const string& name)
3452 assert(name.find("/") == string::npos);
3454 SessionDirectory sdir(get_best_session_directory_for_new_source());
3457 if (type == DataType::AUDIO) {
3458 p = sdir.sound_path();
3459 } else if (type == DataType::MIDI) {
3460 p = sdir.midi_path();
3462 error << "Unknown source type, unable to create file path" << endmsg;
3466 return Glib::build_filename (p, name);
3470 Session::peak_path (string base) const
3472 return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3475 /** Return a unique name based on \a base for a new internal audio source */
3477 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3480 char buf[PATH_MAX+1];
3481 const uint32_t limit = 10000;
3483 string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3486 legalized = legalize_for_path (base);
3488 // Find a "version" of the base name that doesn't exist in any of the possible directories.
3489 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3491 vector<space_and_path>::iterator i;
3492 uint32_t existing = 0;
3494 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3499 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3500 cnt, legalized.c_str(), ext.c_str());
3501 } else if (nchan == 2) {
3503 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3504 cnt, legalized.c_str(), ext.c_str());
3506 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3507 cnt, legalized.c_str(), ext.c_str());
3509 } else if (nchan < 26) {
3510 snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3511 cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3513 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3514 cnt, legalized.c_str(), ext.c_str());
3520 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3521 } else if (nchan == 2) {
3523 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3525 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3527 } else if (nchan < 26) {
3528 snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3530 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3534 SessionDirectory sdir((*i).path);
3536 string spath = sdir.sound_path();
3538 /* note that we search *without* the extension so that
3539 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3540 in the event that this new name is required for
3541 a file format change.
3544 if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3550 if (existing == 0) {
3555 error << string_compose(
3556 _("There are already %1 recordings for %2, which I consider too many."),
3557 limit, base) << endmsg;
3559 throw failed_constructor();
3563 return Glib::path_get_basename (buf);
3566 /** Create a new within-session audio source */
3567 boost::shared_ptr<AudioFileSource>
3568 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3570 const string name = new_audio_source_name (n, n_chans, chan, destructive);
3571 const string path = new_source_path_from_name(DataType::AUDIO, name);
3573 return boost::dynamic_pointer_cast<AudioFileSource> (
3574 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3577 /** Return a unique name based on \a base for a new internal MIDI source */
3579 Session::new_midi_source_name (const string& base)
3582 char buf[PATH_MAX+1];
3583 const uint32_t limit = 10000;
3587 legalized = legalize_for_path (base);
3589 // Find a "version" of the file name that doesn't exist in any of the possible directories.
3590 for (cnt = 1; cnt <= limit; ++cnt) {
3592 vector<space_and_path>::iterator i;
3593 uint32_t existing = 0;
3595 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3597 SessionDirectory sdir((*i).path);
3599 std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3601 snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3603 if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3608 if (existing == 0) {
3613 error << string_compose(
3614 _("There are already %1 recordings for %2, which I consider too many."),
3615 limit, base) << endmsg;
3617 throw failed_constructor();
3621 return Glib::path_get_basename(buf);
3625 /** Create a new within-session MIDI source */
3626 boost::shared_ptr<MidiSource>
3627 Session::create_midi_source_for_session (Track* track, string const & n)
3629 /* try to use the existing write source for the track, to keep numbering sane
3633 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3637 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3640 assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3641 return boost::dynamic_pointer_cast<MidiSource> (l.front());
3645 const string name = new_midi_source_name (n);
3646 const string path = new_source_path_from_name (DataType::MIDI, name);
3648 return boost::dynamic_pointer_cast<SMFSource> (
3649 SourceFactory::createWritable (
3650 DataType::MIDI, *this, path, false, frame_rate()));
3655 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3657 if (playlist->hidden()) {
3661 playlists->add (playlist);
3664 playlist->release();
3671 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3673 if (_state_of_the_state & Deletion) {
3677 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3683 playlists->remove (playlist);
3689 Session::set_audition (boost::shared_ptr<Region> r)
3691 pending_audition_region = r;
3692 add_post_transport_work (PostTransportAudition);
3693 _butler->schedule_transport_work ();
3697 Session::audition_playlist ()
3699 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3700 ev->region.reset ();
3705 Session::non_realtime_set_audition ()
3707 assert (pending_audition_region);
3708 auditioner->audition_region (pending_audition_region);
3709 pending_audition_region.reset ();
3710 AuditionActive (true); /* EMIT SIGNAL */
3714 Session::audition_region (boost::shared_ptr<Region> r)
3716 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3722 Session::cancel_audition ()
3724 if (auditioner->auditioning()) {
3725 auditioner->cancel_audition ();
3726 AuditionActive (false); /* EMIT SIGNAL */
3731 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3733 if (a->is_monitor()) {
3736 if (b->is_monitor()) {
3739 return a->order_key () < b->order_key ();
3743 Session::is_auditioning () const
3745 /* can be called before we have an auditioner object */
3747 return auditioner->auditioning();
3754 Session::graph_reordered ()
3756 /* don't do this stuff if we are setting up connections
3757 from a set_state() call or creating new tracks. Ditto for deletion.
3760 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3764 /* every track/bus asked for this to be handled but it was deferred because
3765 we were connecting. do it now.
3768 request_input_change_handling ();
3772 /* force all diskstreams to update their capture offset values to
3773 reflect any changes in latencies within the graph.
3776 boost::shared_ptr<RouteList> rl = routes.reader ();
3777 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3778 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3780 tr->set_capture_offset ();
3785 /** @return Number of frames that there is disk space available to write,
3788 boost::optional<framecnt_t>
3789 Session::available_capture_duration ()
3791 Glib::Threads::Mutex::Lock lm (space_lock);
3793 if (_total_free_4k_blocks_uncertain) {
3794 return boost::optional<framecnt_t> ();
3797 float sample_bytes_on_disk = 4.0; // keep gcc happy
3799 switch (config.get_native_file_data_format()) {
3801 sample_bytes_on_disk = 4.0;
3805 sample_bytes_on_disk = 3.0;
3809 sample_bytes_on_disk = 2.0;
3813 /* impossible, but keep some gcc versions happy */
3814 fatal << string_compose (_("programming error: %1"),
3815 X_("illegal native file data format"))
3820 double scale = 4096.0 / sample_bytes_on_disk;
3822 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3823 return max_framecnt;
3826 return (framecnt_t) floor (_total_free_4k_blocks * scale);
3830 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3833 RCUWriter<BundleList> writer (_bundles);
3834 boost::shared_ptr<BundleList> b = writer.get_copy ();
3835 b->push_back (bundle);
3838 BundleAdded (bundle); /* EMIT SIGNAL */
3844 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3846 bool removed = false;
3849 RCUWriter<BundleList> writer (_bundles);
3850 boost::shared_ptr<BundleList> b = writer.get_copy ();
3851 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3853 if (i != b->end()) {
3860 BundleRemoved (bundle); /* EMIT SIGNAL */
3866 boost::shared_ptr<Bundle>
3867 Session::bundle_by_name (string name) const
3869 boost::shared_ptr<BundleList> b = _bundles.reader ();
3871 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3872 if ((*i)->name() == name) {
3877 return boost::shared_ptr<Bundle> ();
3881 Session::tempo_map_changed (const PropertyChange&)
3885 playlists->update_after_tempo_map_change ();
3887 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3893 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3895 for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3896 (*i)->recompute_frames_from_bbt ();
3900 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3901 * the given count with the current block size.
3904 Session::ensure_buffers (ChanCount howmany)
3906 BufferManager::ensure_buffers (howmany);
3910 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3912 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3913 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3918 Session::next_insert_id ()
3920 /* this doesn't really loop forever. just think about it */
3923 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3924 if (!insert_bitset[n]) {
3925 insert_bitset[n] = true;
3931 /* none available, so resize and try again */
3933 insert_bitset.resize (insert_bitset.size() + 16, false);
3938 Session::next_send_id ()
3940 /* this doesn't really loop forever. just think about it */
3943 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3944 if (!send_bitset[n]) {
3945 send_bitset[n] = true;
3951 /* none available, so resize and try again */
3953 send_bitset.resize (send_bitset.size() + 16, false);
3958 Session::next_aux_send_id ()
3960 /* this doesn't really loop forever. just think about it */
3963 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3964 if (!aux_send_bitset[n]) {
3965 aux_send_bitset[n] = true;
3971 /* none available, so resize and try again */
3973 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3978 Session::next_return_id ()
3980 /* this doesn't really loop forever. just think about it */
3983 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3984 if (!return_bitset[n]) {
3985 return_bitset[n] = true;
3991 /* none available, so resize and try again */
3993 return_bitset.resize (return_bitset.size() + 16, false);
3998 Session::mark_send_id (uint32_t id)
4000 if (id >= send_bitset.size()) {
4001 send_bitset.resize (id+16, false);
4003 if (send_bitset[id]) {
4004 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4006 send_bitset[id] = true;
4010 Session::mark_aux_send_id (uint32_t id)
4012 if (id >= aux_send_bitset.size()) {
4013 aux_send_bitset.resize (id+16, false);
4015 if (aux_send_bitset[id]) {
4016 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4018 aux_send_bitset[id] = true;
4022 Session::mark_return_id (uint32_t id)
4024 if (id >= return_bitset.size()) {
4025 return_bitset.resize (id+16, false);
4027 if (return_bitset[id]) {
4028 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4030 return_bitset[id] = true;
4034 Session::mark_insert_id (uint32_t id)
4036 if (id >= insert_bitset.size()) {
4037 insert_bitset.resize (id+16, false);
4039 if (insert_bitset[id]) {
4040 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4042 insert_bitset[id] = true;
4046 Session::unmark_send_id (uint32_t id)
4048 if (id < send_bitset.size()) {
4049 send_bitset[id] = false;
4054 Session::unmark_aux_send_id (uint32_t id)
4056 if (id < aux_send_bitset.size()) {
4057 aux_send_bitset[id] = false;
4062 Session::unmark_return_id (uint32_t id)
4064 if (id < return_bitset.size()) {
4065 return_bitset[id] = false;
4070 Session::unmark_insert_id (uint32_t id)
4072 if (id < insert_bitset.size()) {
4073 insert_bitset[id] = false;
4078 Session::reset_native_file_format ()
4080 boost::shared_ptr<RouteList> rl = routes.reader ();
4081 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4082 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4084 /* don't save state as we do this, there's no point
4087 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4088 tr->reset_write_sources (false);
4089 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4095 Session::route_name_unique (string n) const
4097 boost::shared_ptr<RouteList> r = routes.reader ();
4099 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4100 if ((*i)->name() == n) {
4109 Session::route_name_internal (string n) const
4111 if (auditioner && auditioner->name() == n) {
4115 if (_click_io && _click_io->name() == n) {
4123 Session::freeze_all (InterThreadInfo& itt)
4125 boost::shared_ptr<RouteList> r = routes.reader ();
4127 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4129 boost::shared_ptr<Track> t;
4131 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4132 /* XXX this is wrong because itt.progress will keep returning to zero at the start
4142 boost::shared_ptr<Region>
4143 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
4144 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4145 InterThreadInfo& itt,
4146 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4149 boost::shared_ptr<Region> result;
4150 boost::shared_ptr<Playlist> playlist;
4151 boost::shared_ptr<AudioFileSource> fsource;
4153 char buf[PATH_MAX+1];
4154 ChanCount diskstream_channels (track.n_channels());
4155 framepos_t position;
4156 framecnt_t this_chunk;
4159 SessionDirectory sdir(get_best_session_directory_for_new_source ());
4160 const string sound_dir = sdir.sound_path();
4161 framepos_t len = end - start;
4162 bool need_block_size_reset = false;
4164 ChanCount const max_proc = track.max_processor_streams ();
4167 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4168 end, start) << endmsg;
4172 const framecnt_t chunk_size = (256 * 1024)/4;
4174 // block all process callback handling
4176 block_processing ();
4178 /* call tree *MUST* hold route_lock */
4180 if ((playlist = track.playlist()) == 0) {
4184 ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4186 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
4188 for (x = 0; x < 99999; ++x) {
4189 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());
4190 if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
4196 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4201 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4202 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
4205 catch (failed_constructor& err) {
4206 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4210 srcs.push_back (fsource);
4213 /* tell redirects that care that we are about to use a much larger
4214 * blocksize. this will flush all plugins too, so that they are ready
4215 * to be used for this process.
4218 need_block_size_reset = true;
4219 track.set_block_size (chunk_size);
4224 /* create a set of reasonably-sized buffers */
4225 buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4226 buffers.set_count (max_proc);
4228 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4229 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4231 afs->prepare_for_peakfile_writes ();
4234 while (to_do && !itt.cancel) {
4236 this_chunk = min (to_do, chunk_size);
4238 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4243 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4244 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4247 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4253 start += this_chunk;
4254 to_do -= this_chunk;
4256 itt.progress = (float) (1.0 - ((double) to_do / len));
4265 xnow = localtime (&now);
4267 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4268 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4271 afs->update_header (position, *xnow, now);
4272 afs->flush_header ();
4276 /* construct a region to represent the bounced material */
4280 plist.add (Properties::start, 0);
4281 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4282 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4284 result = RegionFactory::create (srcs, plist);
4290 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4291 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4294 afs->mark_for_remove ();
4297 (*src)->drop_references ();
4301 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4302 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4305 afs->done_with_peakfile_writes ();
4310 if (need_block_size_reset) {
4311 track.set_block_size (get_block_size());
4314 unblock_processing ();
4320 Session::gain_automation_buffer() const
4322 return ProcessThread::gain_automation_buffer ();
4326 Session::send_gain_automation_buffer() const
4328 return ProcessThread::send_gain_automation_buffer ();
4332 Session::pan_automation_buffer() const
4334 return ProcessThread::pan_automation_buffer ();
4338 Session::get_silent_buffers (ChanCount count)
4340 return ProcessThread::get_silent_buffers (count);
4344 Session::get_scratch_buffers (ChanCount count, bool silence)
4346 return ProcessThread::get_scratch_buffers (count, silence);
4350 Session::get_route_buffers (ChanCount count, bool silence)
4352 return ProcessThread::get_route_buffers (count, silence);
4357 Session::get_mix_buffers (ChanCount count)
4359 return ProcessThread::get_mix_buffers (count);
4363 Session::ntracks () const
4366 boost::shared_ptr<RouteList> r = routes.reader ();
4368 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4369 if (boost::dynamic_pointer_cast<Track> (*i)) {
4378 Session::nbusses () const
4381 boost::shared_ptr<RouteList> r = routes.reader ();
4383 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4384 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4393 Session::add_automation_list(AutomationList *al)
4395 automation_lists[al->id()] = al;
4398 /** @return true if there is at least one record-enabled track, otherwise false */
4400 Session::have_rec_enabled_track () const
4402 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4405 /** Update the state of our rec-enabled tracks flag */
4407 Session::update_have_rec_enabled_track ()
4409 boost::shared_ptr<RouteList> rl = routes.reader ();
4410 RouteList::iterator i = rl->begin();
4411 while (i != rl->end ()) {
4413 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4414 if (tr && tr->record_enabled ()) {
4421 int const old = g_atomic_int_get (&_have_rec_enabled_track);
4423 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4425 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4426 RecordStateChanged (); /* EMIT SIGNAL */
4431 Session::listen_position_changed ()
4433 boost::shared_ptr<RouteList> r = routes.reader ();
4435 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4436 (*i)->listen_position_changed ();
4441 Session::solo_control_mode_changed ()
4443 /* cancel all solo or all listen when solo control mode changes */
4446 set_solo (get_routes(), false);
4447 } else if (listening()) {
4448 set_listen (get_routes(), false);
4452 /** Called when a property of one of our route groups changes */
4454 Session::route_group_property_changed (RouteGroup* rg)
4456 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4459 /** Called when a route is added to one of our route groups */
4461 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4463 RouteAddedToRouteGroup (rg, r);
4466 /** Called when a route is removed from one of our route groups */
4468 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4470 RouteRemovedFromRouteGroup (rg, r);
4473 boost::shared_ptr<RouteList>
4474 Session::get_routes_with_regions_at (framepos_t const p) const
4476 boost::shared_ptr<RouteList> r = routes.reader ();
4477 boost::shared_ptr<RouteList> rl (new RouteList);
4479 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4480 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4485 boost::shared_ptr<Playlist> pl = tr->playlist ();
4490 if (pl->has_region_at (p)) {
4499 Session::goto_end ()
4501 if (_session_range_location) {
4502 request_locate (_session_range_location->end(), false);
4504 request_locate (0, false);
4509 Session::goto_start ()
4511 if (_session_range_location) {
4512 request_locate (_session_range_location->start(), false);
4514 request_locate (0, false);
4519 Session::current_start_frame () const
4521 return _session_range_location ? _session_range_location->start() : 0;
4525 Session::current_end_frame () const
4527 return _session_range_location ? _session_range_location->end() : 0;
4531 Session::add_session_range_location (framepos_t start, framepos_t end)
4533 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4534 _locations->add (_session_range_location);
4538 Session::step_edit_status_change (bool yn)
4544 send = (_step_editors == 0);
4549 send = (_step_editors == 1);
4552 if (_step_editors > 0) {
4558 StepEditStatusChange (val);
4564 Session::start_time_changed (framepos_t old)
4566 /* Update the auto loop range to match the session range
4567 (unless the auto loop range has been changed by the user)
4570 Location* s = _locations->session_range_location ();
4575 Location* l = _locations->auto_loop_location ();
4577 if (l && l->start() == old) {
4578 l->set_start (s->start(), true);
4583 Session::end_time_changed (framepos_t old)
4585 /* Update the auto loop range to match the session range
4586 (unless the auto loop range has been changed by the user)
4589 Location* s = _locations->session_range_location ();
4594 Location* l = _locations->auto_loop_location ();
4596 if (l && l->end() == old) {
4597 l->set_end (s->end(), true);
4601 std::vector<std::string>
4602 Session::source_search_path (DataType type) const
4606 if (session_dirs.size() == 1) {
4608 case DataType::AUDIO:
4609 sp.push_back (_session_dir->sound_path());
4611 case DataType::MIDI:
4612 sp.push_back (_session_dir->midi_path());
4616 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4617 SessionDirectory sdir (i->path);
4619 case DataType::AUDIO:
4620 sp.push_back (sdir.sound_path());
4622 case DataType::MIDI:
4623 sp.push_back (sdir.midi_path());
4629 if (type == DataType::AUDIO) {
4630 const string sound_path_2X = _session_dir->sound_path_2X();
4631 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4632 if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
4633 sp.push_back (sound_path_2X);
4638 // now check the explicit (possibly user-specified) search path
4641 case DataType::AUDIO:
4642 sp += Searchpath(config.get_audio_search_path ());
4644 case DataType::MIDI:
4645 sp += Searchpath(config.get_midi_search_path ());
4653 Session::ensure_search_path_includes (const string& path, DataType type)
4662 case DataType::AUDIO:
4663 sp += Searchpath(config.get_audio_search_path ());
4665 case DataType::MIDI:
4666 sp += Searchpath (config.get_midi_search_path ());
4670 for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
4671 /* No need to add this new directory if it has the same inode as
4672 an existing one; checking inode rather than name prevents duplicated
4673 directories when we are using symlinks.
4675 On Windows, I think we could just do if (*i == path) here.
4677 if (PBD::equivalent_paths (*i, path)) {
4685 case DataType::AUDIO:
4686 config.set_audio_search_path (sp.to_string());
4688 case DataType::MIDI:
4689 config.set_midi_search_path (sp.to_string());
4694 boost::shared_ptr<Speakers>
4695 Session::get_speakers()
4701 Session::unknown_processors () const
4705 boost::shared_ptr<RouteList> r = routes.reader ();
4706 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4707 list<string> t = (*i)->unknown_processors ();
4708 copy (t.begin(), t.end(), back_inserter (p));
4718 Session::update_latency (bool playback)
4720 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4722 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4726 boost::shared_ptr<RouteList> r = routes.reader ();
4727 framecnt_t max_latency = 0;
4730 /* reverse the list so that we work backwards from the last route to run to the first */
4731 RouteList* rl = routes.reader().get();
4732 r.reset (new RouteList (*rl));
4733 reverse (r->begin(), r->end());
4736 /* compute actual latency values for the given direction and store them all in per-port
4737 structures. this will also publish the same values (to JACK) so that computation of latency
4738 for routes can consistently use public latency values.
4741 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4742 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4745 /* because we latency compensate playback, our published playback latencies should
4746 be the same for all output ports - all material played back by ardour has
4747 the same latency, whether its caused by plugins or by latency compensation. since
4748 these may differ from the values computed above, reset all playback port latencies
4752 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4754 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4755 (*i)->set_public_port_latencies (max_latency, playback);
4760 post_playback_latency ();
4764 post_capture_latency ();
4767 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4771 Session::post_playback_latency ()
4773 set_worst_playback_latency ();
4775 boost::shared_ptr<RouteList> r = routes.reader ();
4777 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4778 if (!(*i)->is_auditioner() && ((*i)->active())) {
4779 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4783 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4784 (*i)->set_latency_compensation (_worst_track_latency);
4789 Session::post_capture_latency ()
4791 set_worst_capture_latency ();
4793 /* reflect any changes in capture latencies into capture offsets
4796 boost::shared_ptr<RouteList> rl = routes.reader();
4797 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4798 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4800 tr->set_capture_offset ();
4806 Session::initialize_latencies ()
4809 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4810 update_latency (false);
4811 update_latency (true);
4814 set_worst_io_latencies ();
4818 Session::set_worst_io_latencies ()
4820 set_worst_playback_latency ();
4821 set_worst_capture_latency ();
4825 Session::set_worst_playback_latency ()
4827 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4831 _worst_output_latency = 0;
4833 if (!_engine.connected()) {
4837 boost::shared_ptr<RouteList> r = routes.reader ();
4839 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4840 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4843 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4847 Session::set_worst_capture_latency ()
4849 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4853 _worst_input_latency = 0;
4855 if (!_engine.connected()) {
4859 boost::shared_ptr<RouteList> r = routes.reader ();
4861 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4862 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4865 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4869 Session::update_latency_compensation (bool force_whole_graph)
4871 bool some_track_latency_changed = false;
4873 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4877 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4879 _worst_track_latency = 0;
4881 boost::shared_ptr<RouteList> r = routes.reader ();
4883 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4884 if (!(*i)->is_auditioner() && ((*i)->active())) {
4886 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4887 some_track_latency_changed = true;
4889 _worst_track_latency = max (tl, _worst_track_latency);
4893 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4894 (some_track_latency_changed ? "yes" : "no")));
4896 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4898 if (some_track_latency_changed || force_whole_graph) {
4899 _engine.update_latencies ();
4903 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4904 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4908 tr->set_capture_offset ();
4913 Session::session_name_is_legal (const string& path)
4915 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4917 for (int i = 0; illegal_chars[i]; ++i) {
4918 if (path.find (illegal_chars[i]) != string::npos) {
4919 return illegal_chars[i];
4927 Session::next_control_id () const
4931 /* the monitor bus remote ID is in a different
4932 * "namespace" than regular routes. its existence doesn't
4933 * affect normal (low) numbered routes.
4940 return nroutes() - subtract;
4944 Session::notify_remote_id_change ()
4946 if (deletion_in_progress()) {
4950 switch (Config->get_remote_model()) {
4952 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4960 Session::sync_order_keys ()
4962 if (deletion_in_progress()) {
4966 /* tell everyone that something has happened to the sort keys
4967 and let them sync up with the change(s)
4968 this will give objects that manage the sort order keys the
4969 opportunity to keep them in sync if they wish to.
4972 DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
4974 Route::SyncOrderKeys (); /* EMIT SIGNAL */
4976 DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
4980 Session::operation_in_progress (GQuark op) const
4982 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4985 boost::shared_ptr<Port>
4986 Session::ltc_input_port () const
4988 return _ltc_input->nth (0);
4991 boost::shared_ptr<Port>
4992 Session::ltc_output_port () const
4994 return _ltc_output->nth (0);
4998 Session::reconnect_ltc_input ()
5002 string src = Config->get_ltc_source_port();
5004 _ltc_input->disconnect (this);
5006 if (src != _("None") && !src.empty()) {
5007 _ltc_input->nth (0)->connect (src);
5013 Session::reconnect_ltc_output ()
5018 string src = Config->get_ltc_sink_port();
5020 _ltc_output->disconnect (this);
5022 if (src != _("None") && !src.empty()) {
5023 _ltc_output->nth (0)->connect (src);