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.
26 #include <cstdio> /* sprintf(3) ... grrr */
32 #include <glibmm/threads.h>
33 #include <glibmm/miscutils.h>
34 #include <glibmm/fileutils.h>
36 #include <boost/algorithm/string/erase.hpp>
38 #include "pbd/basename.h"
39 #include "pbd/convert.h"
40 #include "pbd/error.h"
41 #include "pbd/file_utils.h"
43 #include "pbd/pthread_utils.h"
44 #include "pbd/search_path.h"
45 #include "pbd/stacktrace.h"
46 #include "pbd/stl_delete.h"
47 #include "pbd/replace_all.h"
48 #include "pbd/unwind.h"
50 #include "ardour/amp.h"
51 #include "ardour/analyser.h"
52 #include "ardour/async_midi_port.h"
53 #include "ardour/audio_buffer.h"
54 #include "ardour/audio_diskstream.h"
55 #include "ardour/audio_port.h"
56 #include "ardour/audio_track.h"
57 #include "ardour/audioengine.h"
58 #include "ardour/audiofilesource.h"
59 #include "ardour/auditioner.h"
60 #include "ardour/boost_debug.h"
61 #include "ardour/buffer_manager.h"
62 #include "ardour/buffer_set.h"
63 #include "ardour/bundle.h"
64 #include "ardour/butler.h"
65 #include "ardour/click.h"
66 #include "ardour/control_protocol_manager.h"
67 #include "ardour/data_type.h"
68 #include "ardour/debug.h"
69 #include "ardour/directory_names.h"
70 #ifdef USE_TRACKS_CODE_FEATURES
71 #include "ardour/engine_state_controller.h"
73 #include "ardour/filename_extensions.h"
74 #include "ardour/gain_control.h"
75 #include "ardour/graph.h"
76 #include "ardour/luabindings.h"
77 #include "ardour/midiport_manager.h"
78 #include "ardour/scene_changer.h"
79 #include "ardour/midi_patch_manager.h"
80 #include "ardour/midi_track.h"
81 #include "ardour/midi_ui.h"
82 #include "ardour/operations.h"
83 #include "ardour/playlist.h"
84 #include "ardour/playlist_factory.h"
85 #include "ardour/plugin.h"
86 #include "ardour/plugin_insert.h"
87 #include "ardour/process_thread.h"
88 #include "ardour/profile.h"
89 #include "ardour/rc_configuration.h"
90 #include "ardour/recent_sessions.h"
91 #include "ardour/region.h"
92 #include "ardour/region_factory.h"
93 #include "ardour/revision.h"
94 #include "ardour/route_graph.h"
95 #include "ardour/route_group.h"
96 #include "ardour/send.h"
97 #include "ardour/selection.h"
98 #include "ardour/session.h"
99 #include "ardour/session_directory.h"
100 #include "ardour/session_playlists.h"
101 #include "ardour/smf_source.h"
102 #include "ardour/solo_isolate_control.h"
103 #include "ardour/source_factory.h"
104 #include "ardour/speakers.h"
105 #include "ardour/tempo.h"
106 #include "ardour/ticker.h"
107 #include "ardour/track.h"
108 #include "ardour/types_convert.h"
109 #include "ardour/user_bundle.h"
110 #include "ardour/utils.h"
111 #include "ardour/vca_manager.h"
112 #include "ardour/vca.h"
114 #include "midi++/port.h"
115 #include "midi++/mmc.h"
117 #include "LuaBridge/LuaBridge.h"
119 #include "pbd/i18n.h"
121 #include <glibmm/checksum.h>
130 using namespace ARDOUR;
133 bool Session::_disable_all_loaded_plugins = false;
134 bool Session::_bypass_all_loaded_plugins = false;
135 guint Session::_name_id_counter = 0;
137 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
138 PBD::Signal1<void,std::string> Session::Dialog;
139 PBD::Signal0<int> Session::AskAboutPendingState;
140 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
141 PBD::Signal2<void, framecnt_t, framecnt_t> Session::NotifyAboutSampleRateMismatch;
142 PBD::Signal0<void> Session::SendFeedback;
143 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
145 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
146 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
147 PBD::Signal2<void,std::string, std::string> Session::Exported;
148 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
149 PBD::Signal0<void> Session::Quit;
150 PBD::Signal0<void> Session::FeedbackDetected;
151 PBD::Signal0<void> Session::SuccessfulGraphSort;
152 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
154 const framecnt_t Session::bounce_chunk_size = 8192;
155 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
156 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
158 // seconds should be added after the region exceeds end marker
159 #ifdef USE_TRACKS_CODE_FEATURES
160 const uint32_t Session::session_end_shift = 5;
162 const uint32_t Session::session_end_shift = 0;
165 /** @param snapshot_name Snapshot name, without .ardour suffix */
166 Session::Session (AudioEngine &eng,
167 const string& fullpath,
168 const string& snapshot_name,
169 BusProfile* bus_profile,
171 : playlists (new SessionPlaylists)
173 , process_function (&Session::process_with_events)
174 , _bounce_processing_active (false)
175 , waiting_for_sync_offset (false)
176 , _base_frame_rate (0)
177 , _nominal_frame_rate (0)
178 , _current_frame_rate (0)
179 , transport_sub_state (0)
180 , _record_status (Disabled)
181 , _transport_frame (0)
182 , _session_range_location (0)
183 , _session_range_end_is_free (true)
186 , _transport_speed (0)
187 , _default_transport_speed (1.0)
188 , _last_transport_speed (0)
189 , _target_transport_speed (0.0)
190 , auto_play_legal (false)
191 , _last_slave_transport_frame (0)
192 , maximum_output_latency (0)
193 , _requested_return_frame (-1)
194 , current_block_size (0)
195 , _worst_output_latency (0)
196 , _worst_input_latency (0)
197 , _worst_track_latency (0)
198 , _have_captured (false)
199 , _non_soloed_outs_muted (false)
202 , _solo_isolated_cnt (0)
204 , _was_seamless (Config->get_seamless_loop ())
205 , _under_nsm_control (false)
207 , delta_accumulator_cnt (0)
208 , average_slave_delta (1800) // !!! why 1800 ???
210 , have_first_delta_accumulator (false)
211 , _slave_state (Stopped)
212 , _mtc_active (false)
213 , _ltc_active (false)
214 , post_export_sync (false)
215 , post_export_position (0)
217 , _export_rolling (false)
218 , _realtime_export (false)
219 , _region_export (false)
220 , _export_preroll (0)
221 , _export_latency (0)
222 , _pre_export_mmc_enabled (false)
223 , _name (snapshot_name)
225 , _send_qf_mtc (false)
226 , _pframes_since_last_mtc (0)
228 , loop_changing (false)
230 , _session_dir (new SessionDirectory (fullpath))
231 , _current_snapshot_name (snapshot_name)
233 , state_was_pending (false)
234 , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
236 , _save_queued (false)
237 , _last_roll_location (0)
238 , _last_roll_or_reversal_location (0)
239 , _last_record_location (0)
240 , pending_locate_roll (false)
241 , pending_locate_frame (0)
242 , pending_locate_flush (false)
243 , pending_abort (false)
244 , pending_auto_loop (false)
245 , _mempool ("Session", 3145728)
246 , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
248 , _butler (new Butler (*this))
249 , _post_transport_work (0)
250 , cumulative_rf_motion (0)
252 , _locations (new Locations (*this))
253 , _ignore_skips_updates (false)
254 , _rt_thread_active (false)
255 , _rt_emit_pending (false)
256 , _ac_thread_active (0)
257 , _latency_recompute_pending (0)
259 , outbound_mtc_timecode_frame (0)
260 , next_quarter_frame_to_send (-1)
261 , _samples_per_timecode_frame (0)
262 , _frames_per_hour (0)
263 , _timecode_frames_per_hour (0)
264 , last_timecode_valid (false)
265 , last_timecode_when (0)
266 , _send_timecode_update (false)
278 , ltc_timecode_offset (0)
279 , ltc_timecode_negative_offset (false)
280 , midi_control_ui (0)
282 , _all_route_group (new RouteGroup (*this, "all"))
283 , routes (new RouteList)
284 , _adding_routes_in_progress (false)
285 , _reconnecting_routes_in_progress (false)
286 , _route_deletion_in_progress (false)
287 , destructive_index (0)
288 , _track_number_decimals(1)
289 , default_fade_steepness (0)
290 , default_fade_msecs (0)
291 , _total_free_4k_blocks (0)
292 , _total_free_4k_blocks_uncertain (false)
293 , no_questions_about_missing_files (false)
296 , _bundles (new BundleList)
297 , _bundle_xml_node (0)
300 , _click_rec_only (false)
302 , click_emphasis_data (0)
304 , click_emphasis_length (0)
305 , _clicks_cleared (0)
306 , _count_in_samples (0)
307 , _play_range (false)
308 , _range_selection (-1,-1)
309 , _object_selection (-1,-1)
310 , _preroll_record_punch_pos (-1)
311 , _preroll_record_trim_len (0)
312 , _count_in_once (false)
314 , first_file_data_format_reset (true)
315 , first_file_header_format_reset (true)
316 , have_looped (false)
317 , _have_rec_enabled_track (false)
318 , _have_rec_disabled_track (true)
320 , _suspend_timecode_transmission (0)
321 , _speakers (new Speakers)
322 , _ignore_route_processor_changes (0)
327 , _vca_manager (new VCAManager (*this))
328 , _selection (new CoreSelection (*this))
332 created_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
334 pthread_mutex_init (&_rt_emit_mutex, 0);
335 pthread_cond_init (&_rt_emit_cond, 0);
337 pthread_mutex_init (&_auto_connect_mutex, 0);
338 pthread_cond_init (&_auto_connect_cond, 0);
340 init_name_id_counter (1); // reset for new sessions, start at 1
341 VCA::set_next_vca_number (1); // reset for new sessions, start at 1
343 pre_engine_init (fullpath); // sets _is_new
349 Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
351 #ifdef USE_TRACKS_CODE_FEATURES
352 sr = EngineStateController::instance()->get_current_sample_rate();
354 if (ensure_engine (sr, true)) {
356 throw SessionException (_("Cannot connect to audio/midi engine"));
359 // set samplerate for plugins added early
360 // e.g from templates or MB channelstrip
361 set_block_size (_engine.samples_per_cycle());
362 set_frame_rate (_engine.sample_rate());
364 if (create (mix_template, bus_profile)) {
366 throw SessionException (_("Session initialization failed"));
369 /* if a mix template was provided, then ::create() will
370 * have copied it into the session and we need to load it
371 * so that we have the state ready for ::set_state()
372 * after the engine is started.
374 * Note that we do NOT try to get the sample rate from
375 * the template at this time, though doing so would
376 * be easy if we decided this was an appropriate part
380 if (!mix_template.empty()) {
381 if (load_state (_current_snapshot_name)) {
382 throw SessionException (_("Failed to load template/snapshot state"));
384 store_recent_templates (mix_template);
387 /* load default session properties - if any */
392 if (load_state (_current_snapshot_name)) {
393 throw SessionException (_("Failed to load state"));
396 /* try to get sample rate from XML state so that we
397 * can influence the SR if we set up the audio
402 XMLProperty const * prop;
403 XMLNode const * root (state_tree->root());
404 if ((prop = root->property (X_("sample-rate"))) != 0) {
405 sr = atoi (prop->value());
409 if (ensure_engine (sr, false)) {
411 throw SessionException (_("Cannot connect to audio/midi engine"));
415 int err = post_engine_init ();
420 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Failed to create background threads.")));
424 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Invalid TempoMap in session-file.")));
427 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Invalid or corrupt session state.")));
430 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Port registration failed.")));
433 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Unexpected exception during session setup, possibly invalid audio/midi engine parameters. Please see stdout/stderr for details")));
438 store_recent_sessions (_name, _path);
440 bool was_dirty = dirty();
442 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
444 PresentationInfo::Change.connect_same_thread (*this, boost::bind (&Session::notify_presentation_info_change, this));
446 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
447 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
450 DirtyChanged (); /* EMIT SIGNAL */
453 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
454 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
456 emit_thread_start ();
457 auto_connect_thread_start ();
459 /* hook us up to the engine since we are now completely constructed */
461 BootMessage (_("Connect to engine"));
463 _engine.set_session (this);
464 _engine.reset_timebase ();
466 #ifdef USE_TRACKS_CODE_FEATURES
468 EngineStateController::instance()->set_session(this);
471 if ( ARDOUR::Profile->get_trx () ) {
473 /* Waves Tracks: fill session with tracks basing on the amount of inputs.
474 * each available input must have corresponding track when session starts.
477 uint32_t how_many (0);
479 std::vector<std::string> inputs;
480 EngineStateController::instance()->get_physical_audio_inputs(inputs);
482 how_many = inputs.size();
484 list<boost::shared_ptr<AudioTrack> > tracks;
486 // Track names after driver
487 if (Config->get_tracks_auto_naming() == NameAfterDriver) {
488 string track_name = "";
489 for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
491 track_name = inputs[i];
492 replace_all (track_name, "system:capture", "");
494 list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
495 tracks.insert(tracks.begin(), single_track.front());
497 } else { // Default track names
498 tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
501 if (tracks.size() != how_many) {
503 throw failed_constructor ();
509 ensure_subdirs (); // archived or zipped sessions may lack peaks/ analysis/ etc
514 BootMessage (_("Session loading complete"));
526 Session::next_name_id ()
528 return g_atomic_int_add (&_name_id_counter, 1);
532 Session::name_id_counter ()
534 return g_atomic_int_get (&_name_id_counter);
538 Session::init_name_id_counter (guint n)
540 g_atomic_int_set (&_name_id_counter, n);
544 Session::ensure_engine (uint32_t desired_sample_rate, bool isnew)
546 if (_engine.current_backend() == 0) {
547 /* backend is unknown ... */
548 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
549 if (r.get_value_or (-1) != 0) {
552 } else if (!isnew && _engine.running() && _engine.sample_rate () == desired_sample_rate) {
554 } else if (_engine.setup_required()) {
555 /* backend is known, but setup is needed */
556 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
557 if (r.get_value_or (-1) != 0) {
560 } else if (!_engine.running()) {
561 if (_engine.start()) {
566 /* at this point the engine should be running */
568 if (!_engine.running()) {
572 return immediately_post_engine ();
577 Session::immediately_post_engine ()
579 /* Do various initializations that should take place directly after we
580 * know that the engine is running, but before we either create a
581 * session or set state for an existing one.
584 if (how_many_dsp_threads () > 1) {
585 /* For now, only create the graph if we are using >1 DSP threads, as
586 it is a bit slower than the old code with 1 thread.
588 _process_graph.reset (new Graph (*this));
591 /* every time we reconnect, recompute worst case output latencies */
593 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
595 if (synced_to_engine()) {
596 _engine.transport_stop ();
599 if (config.get_jack_time_master()) {
600 _engine.transport_locate (_transport_frame);
604 BootMessage (_("Set up LTC"));
606 BootMessage (_("Set up Click"));
608 BootMessage (_("Set up standard connections"));
612 catch (failed_constructor& err) {
616 /* TODO, connect in different thread. (PortRegisteredOrUnregistered may be in RT context)
618 _engine.PortRegisteredOrUnregistered.connect_same_thread (*this, boost::bind (&Session::setup_bundles, this));
626 vector<void*> debug_pointers;
628 /* if we got to here, leaving pending capture state around
632 remove_pending_capture_state ();
636 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
638 /* disconnect from any and all signals that we are connected to */
640 Port::PortSignalDrop (); /* EMIT SIGNAL */
643 /* shutdown control surface protocols while we still have ports
644 and the engine to move data to any devices.
647 ControlProtocolManager::instance().drop_protocols ();
649 /* stop auto dis/connecting */
650 auto_connect_thread_terminate ();
652 MIDI::Name::MidiPatchManager::instance().remove_search_path(session_directory().midi_patch_path());
654 _engine.remove_session ();
656 #ifdef USE_TRACKS_CODE_FEATURES
657 EngineStateController::instance()->remove_session();
660 /* deregister all ports - there will be no process or any other
661 * callbacks from the engine any more.
664 Port::PortDrop (); /* EMIT SIGNAL */
668 /* clear history so that no references to objects are held any more */
672 /* clear state tree so that no references to objects are held any more */
677 // unregister all lua functions, drop held references (if any)
679 lua.do_command ("Session = nil");
687 lua.collect_garbage ();
689 /* reset dynamic state version back to default */
690 Stateful::loading_state_version = 0;
692 _butler->drop_references ();
696 delete _all_route_group;
698 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
699 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
703 if (click_data != default_click) {
704 delete [] click_data;
707 if (click_emphasis_data != default_click_emphasis) {
708 delete [] click_emphasis_data;
713 /* need to remove auditioner before monitoring section
714 * otherwise it is re-connected */
717 /* drop references to routes held by the monitoring section
718 * specifically _monitor_out aux/listen references */
719 remove_monitor_section();
721 /* clear out any pending dead wood from RCU managed objects */
726 AudioDiskstream::free_working_buffers();
728 /* tell everyone who is still standing that we're about to die */
731 /* tell everyone to drop references and delete objects as we go */
733 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
734 RegionFactory::delete_all_regions ();
736 /* Do this early so that VCAs no longer hold references to routes */
738 DEBUG_TRACE (DEBUG::Destruction, "delete vcas\n");
741 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
743 /* reset these three references to special routes before we do the usual route delete thing */
745 _master_out.reset ();
746 _monitor_out.reset ();
749 RCUWriter<RouteList> writer (routes);
750 boost::shared_ptr<RouteList> r = writer.get_copy ();
752 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
753 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
754 (*i)->drop_references ();
758 /* writer goes out of scope and updates master */
763 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
764 Glib::Threads::Mutex::Lock lm (source_lock);
765 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
766 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
767 i->second->drop_references ();
773 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
776 emit_thread_terminate ();
778 pthread_cond_destroy (&_rt_emit_cond);
779 pthread_mutex_destroy (&_rt_emit_mutex);
781 pthread_cond_destroy (&_auto_connect_cond);
782 pthread_mutex_destroy (&_auto_connect_mutex);
784 delete _scene_changer; _scene_changer = 0;
785 delete midi_control_ui; midi_control_ui = 0;
787 delete _mmc; _mmc = 0;
788 delete _midi_ports; _midi_ports = 0;
789 delete _locations; _locations = 0;
794 /* clear event queue, the session is gone, nobody is interested in
795 * those anymore, but they do leak memory if not removed
797 while (!immediate_events.empty ()) {
798 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
799 SessionEvent *ev = immediate_events.front ();
800 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Drop event: %1\n", enum_2_string (ev->type)));
801 immediate_events.pop_front ();
805 case SessionEvent::AutoLoop:
806 case SessionEvent::AutoLoopDeclick:
807 case SessionEvent::Skip:
808 case SessionEvent::PunchIn:
809 case SessionEvent::PunchOut:
810 case SessionEvent::RecordStart:
811 case SessionEvent::StopOnce:
812 case SessionEvent::RangeStop:
813 case SessionEvent::RangeLocate:
817 case SessionEvent::RealTimeOperation:
824 del = del && !_remove_event (ev);
832 /* unregister all dropped ports, process pending port deletion. */
833 // this may call ARDOUR::Port::drop ... jack_port_unregister ()
834 // jack1 cannot cope with removing ports while processing
835 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
836 AudioEngine::instance()->clear_pending_port_deletions ();
839 DEBUG_TRACE (DEBUG::Destruction, "delete selection\n");
843 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
845 BOOST_SHOW_POINTERS ();
849 Session::setup_ltc ()
853 _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
854 _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
856 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
857 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
860 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
861 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
862 // TODO use auto-connect thread somehow (needs a route currently)
863 // see note in Session::auto_connect_thread_run() why process lock is needed.
864 reconnect_ltc_input ();
868 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
869 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
872 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
873 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
874 // TODO use auto-connect thread
875 reconnect_ltc_output ();
879 /* fix up names of LTC ports because we don't want the normal
880 * IO style of NAME/TYPE-{in,out}N
883 _ltc_input->nth (0)->set_name (X_("LTC-in"));
884 _ltc_output->nth (0)->set_name (X_("LTC-out"));
888 Session::setup_click ()
892 boost::shared_ptr<AutomationList> gl (new AutomationList (Evoral::Parameter (GainAutomation)));
893 boost::shared_ptr<GainControl> gain_control = boost::shared_ptr<GainControl> (new GainControl (*this, Evoral::Parameter(GainAutomation), gl));
895 _click_io.reset (new ClickIO (*this, X_("Click")));
896 _click_gain.reset (new Amp (*this, _("Fader"), gain_control, true));
897 _click_gain->activate ();
899 setup_click_state (state_tree->root());
901 setup_click_state (0);
906 Session::setup_click_state (const XMLNode* node)
908 const XMLNode* child = 0;
910 if (node && (child = find_named_node (*node, "Click")) != 0) {
912 /* existing state for Click */
915 if (Stateful::loading_state_version < 3000) {
916 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
918 const XMLNodeList& children (child->children());
919 XMLNodeList::const_iterator i = children.begin();
920 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
922 if (i != children.end()) {
923 c = _click_gain->set_state (**i, Stateful::loading_state_version);
929 _clicking = Config->get_clicking ();
933 error << _("could not setup Click I/O") << endmsg;
940 /* default state for Click: dual-mono to first 2 physical outputs */
943 _engine.get_physical_outputs (DataType::AUDIO, outs);
945 for (uint32_t physport = 0; physport < 2; ++physport) {
946 if (outs.size() > physport) {
947 if (_click_io->add_port (outs[physport], this)) {
948 // relax, even though its an error
953 if (_click_io->n_ports () > ChanCount::ZERO) {
954 _clicking = Config->get_clicking ();
960 Session::get_physical_ports (vector<string>& inputs, vector<string>& outputs, DataType type,
961 MidiPortFlags include, MidiPortFlags exclude)
963 _engine.get_physical_inputs (type, inputs, include, exclude);
964 _engine.get_physical_outputs (type, outputs, include, exclude);
968 Session::setup_bundles ()
972 RCUWriter<BundleList> writer (_bundles);
973 boost::shared_ptr<BundleList> b = writer.get_copy ();
974 for (BundleList::iterator i = b->begin(); i != b->end();) {
975 if (boost::dynamic_pointer_cast<UserBundle>(*i)) {
983 vector<string> inputs[DataType::num_types];
984 vector<string> outputs[DataType::num_types];
986 for (uint32_t i = 0; i < DataType::num_types; ++i) {
987 get_physical_ports (inputs[i], outputs[i], DataType (DataType::Symbol (i)),
988 MidiPortFlags (0), /* no specific inclusions */
989 MidiPortFlags (MidiPortControl|MidiPortVirtual) /* exclude control & virtual ports */
993 /* Create a set of Bundle objects that map
994 to the physical I/O currently available. We create both
995 mono and stereo bundles, so that the common cases of mono
996 and stereo tracks get bundles to put in their mixer strip
997 in / out menus. There may be a nicer way of achieving that;
998 it doesn't really scale that well to higher channel counts
1001 /* mono output bundles */
1003 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
1005 std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
1007 snprintf (buf, sizeof (buf), _("out %s"), pn.c_str());
1009 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
1012 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
1013 c->add_channel (_("mono"), DataType::AUDIO);
1014 c->set_port (0, outputs[DataType::AUDIO][np]);
1016 add_bundle (c, false);
1019 /* stereo output bundles */
1021 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
1022 if (np + 1 < outputs[DataType::AUDIO].size()) {
1024 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1025 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
1026 c->add_channel (_("L"), DataType::AUDIO);
1027 c->set_port (0, outputs[DataType::AUDIO][np]);
1028 c->add_channel (_("R"), DataType::AUDIO);
1029 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
1031 add_bundle (c, false);
1035 /* mono input bundles */
1037 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
1039 std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
1041 snprintf (buf, sizeof (buf), _("in %s"), pn.c_str());
1043 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
1046 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1047 c->add_channel (_("mono"), DataType::AUDIO);
1048 c->set_port (0, inputs[DataType::AUDIO][np]);
1050 add_bundle (c, false);
1053 /* stereo input bundles */
1055 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
1056 if (np + 1 < inputs[DataType::AUDIO].size()) {
1058 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1060 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1061 c->add_channel (_("L"), DataType::AUDIO);
1062 c->set_port (0, inputs[DataType::AUDIO][np]);
1063 c->add_channel (_("R"), DataType::AUDIO);
1064 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
1066 add_bundle (c, false);
1070 /* MIDI input bundles */
1072 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
1073 string n = inputs[DataType::MIDI][np];
1075 std::string pn = _engine.get_pretty_name_by_name (n);
1079 boost::erase_first (n, X_("alsa_pcm:"));
1081 boost::shared_ptr<Bundle> c (new Bundle (n, false));
1082 c->add_channel ("", DataType::MIDI);
1083 c->set_port (0, inputs[DataType::MIDI][np]);
1084 add_bundle (c, false);
1087 /* MIDI output bundles */
1089 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
1090 string n = outputs[DataType::MIDI][np];
1091 std::string pn = _engine.get_pretty_name_by_name (n);
1095 boost::erase_first (n, X_("alsa_pcm:"));
1097 boost::shared_ptr<Bundle> c (new Bundle (n, true));
1098 c->add_channel ("", DataType::MIDI);
1099 c->set_port (0, outputs[DataType::MIDI][np]);
1100 add_bundle (c, false);
1103 // we trust the backend to only calls us if there's a change
1104 BundleAddedOrRemoved (); /* EMIT SIGNAL */
1108 Session::auto_connect_master_bus ()
1110 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
1114 // Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
1115 // In this case it means "Multi Out" output mode
1116 if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
1120 /* if requested auto-connect the outputs to the first N physical ports.
1123 uint32_t limit = _master_out->n_outputs().n_total();
1124 vector<string> outputs[DataType::num_types];
1126 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1127 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1130 for (uint32_t n = 0; n < limit; ++n) {
1131 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
1133 if (outputs[p->type()].size() > n) {
1134 connect_to = outputs[p->type()][n];
1137 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
1138 if (_master_out->output()->connect (p, connect_to, this)) {
1139 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
1148 Session::remove_monitor_section ()
1150 if (!_monitor_out || Profile->get_trx()) {
1154 /* force reversion to Solo-In-Place */
1155 Config->set_solo_control_is_listen_control (false);
1157 /* if we are auditioning, cancel it ... this is a workaround
1158 to a problem (auditioning does not execute the process graph,
1159 which is needed to remove routes when using >1 core for processing)
1164 /* Hold process lock while doing this so that we don't hear bits and
1165 * pieces of audio as we work on each route.
1168 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1170 /* Connect tracks to monitor section. Note that in an
1171 existing session, the internal sends will already exist, but we want the
1172 routes to notice that they connect to the control out specifically.
1176 boost::shared_ptr<RouteList> r = routes.reader ();
1177 ProcessorChangeBlocker pcb (this, false);
1179 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
1181 if ((*x)->is_monitor()) {
1183 } else if ((*x)->is_master()) {
1186 (*x)->remove_aux_or_listen (_monitor_out);
1191 remove_route (_monitor_out);
1192 if (_state_of_the_state & Deletion) {
1196 auto_connect_master_bus ();
1199 auditioner->connect ();
1202 Config->ParameterChanged ("use-monitor-bus");
1206 Session::add_monitor_section ()
1210 if (_monitor_out || !_master_out || Profile->get_trx()) {
1214 boost::shared_ptr<Route> r (new Route (*this, _("Monitor"), PresentationInfo::MonitorOut, DataType::AUDIO));
1220 BOOST_MARK_ROUTE(r);
1223 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1224 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1225 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1227 error << _("Cannot create monitor section. 'Monitor' Port name is not unique.") << endmsg;
1232 add_routes (rl, false, false, false, 0);
1234 assert (_monitor_out);
1236 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
1237 are undefined, at best.
1240 uint32_t limit = _monitor_out->n_inputs().n_audio();
1244 /* connect the inputs to the master bus outputs. this
1245 * represents a separate data feed from the internal sends from
1246 * each route. as of jan 2011, it allows the monitor section to
1247 * conditionally ignore either the internal sends or the normal
1248 * input feed, but we should really find a better way to do
1252 _master_out->output()->disconnect (this);
1254 for (uint32_t n = 0; n < limit; ++n) {
1255 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1256 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1259 string connect_to = o->name();
1260 if (_monitor_out->input()->connect (p, connect_to, this)) {
1261 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1269 /* if monitor section is not connected, connect it to physical outs
1272 if ((Config->get_auto_connect_standard_busses () || Profile->get_mixbus ()) && !_monitor_out->output()->connected ()) {
1274 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1276 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1279 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1281 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1282 Config->get_monitor_bus_preferred_bundle())
1288 /* Monitor bus is audio only */
1290 vector<string> outputs[DataType::num_types];
1292 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1293 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1296 uint32_t mod = outputs[DataType::AUDIO].size();
1297 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1301 for (uint32_t n = 0; n < limit; ++n) {
1303 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1305 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1306 connect_to = outputs[DataType::AUDIO][n % mod];
1309 if (!connect_to.empty()) {
1310 if (_monitor_out->output()->connect (p, connect_to, this)) {
1311 error << string_compose (
1312 _("cannot connect control output %1 to %2"),
1323 /* Hold process lock while doing this so that we don't hear bits and
1324 * pieces of audio as we work on each route.
1327 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1329 /* Connect tracks to monitor section. Note that in an
1330 existing session, the internal sends will already exist, but we want the
1331 routes to notice that they connect to the control out specifically.
1335 boost::shared_ptr<RouteList> rls = routes.reader ();
1337 ProcessorChangeBlocker pcb (this, false /* XXX */);
1339 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1341 if ((*x)->is_monitor()) {
1343 } else if ((*x)->is_master()) {
1346 (*x)->enable_monitor_send ();
1351 auditioner->connect ();
1353 Config->ParameterChanged ("use-monitor-bus");
1357 Session::reset_monitor_section ()
1359 /* Process lock should be held by the caller.*/
1361 if (!_monitor_out || Profile->get_trx()) {
1365 uint32_t limit = _master_out->n_outputs().n_audio();
1367 /* connect the inputs to the master bus outputs. this
1368 * represents a separate data feed from the internal sends from
1369 * each route. as of jan 2011, it allows the monitor section to
1370 * conditionally ignore either the internal sends or the normal
1371 * input feed, but we should really find a better way to do
1375 _master_out->output()->disconnect (this);
1376 _monitor_out->output()->disconnect (this);
1378 // monitor section follow master bus - except midi
1379 ChanCount mon_chn (_master_out->output()->n_ports());
1380 mon_chn.set_midi (0);
1382 _monitor_out->input()->ensure_io (mon_chn, false, this);
1383 _monitor_out->output()->ensure_io (mon_chn, false, this);
1385 for (uint32_t n = 0; n < limit; ++n) {
1386 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1387 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1390 string connect_to = o->name();
1391 if (_monitor_out->input()->connect (p, connect_to, this)) {
1392 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1399 /* connect monitor section to physical outs
1402 if (Config->get_auto_connect_standard_busses()) {
1404 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1406 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1409 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1411 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1412 Config->get_monitor_bus_preferred_bundle())
1418 /* Monitor bus is audio only */
1420 vector<string> outputs[DataType::num_types];
1422 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1423 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1426 uint32_t mod = outputs[DataType::AUDIO].size();
1427 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1431 for (uint32_t n = 0; n < limit; ++n) {
1433 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1435 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1436 connect_to = outputs[DataType::AUDIO][n % mod];
1439 if (!connect_to.empty()) {
1440 if (_monitor_out->output()->connect (p, connect_to, this)) {
1441 error << string_compose (
1442 _("cannot connect control output %1 to %2"),
1453 /* Connect tracks to monitor section. Note that in an
1454 existing session, the internal sends will already exist, but we want the
1455 routes to notice that they connect to the control out specifically.
1459 boost::shared_ptr<RouteList> rls = routes.reader ();
1461 ProcessorChangeBlocker pcb (this, false);
1463 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1465 if ((*x)->is_monitor()) {
1467 } else if ((*x)->is_master()) {
1470 (*x)->enable_monitor_send ();
1476 Session::hookup_io ()
1478 /* stop graph reordering notifications from
1479 causing resorts, etc.
1482 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1486 /* we delay creating the auditioner till now because
1487 it makes its own connections to ports.
1491 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1493 throw failed_constructor ();
1495 a->use_new_diskstream ();
1499 catch (failed_constructor& err) {
1500 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1504 /* load bundles, which we may have postponed earlier on */
1505 if (_bundle_xml_node) {
1506 load_bundles (*_bundle_xml_node);
1507 delete _bundle_xml_node;
1510 /* Tell all IO objects to connect themselves together */
1512 IO::enable_connecting ();
1514 /* Now tell all "floating" ports to connect to whatever
1515 they should be connected to.
1518 AudioEngine::instance()->reconnect_ports ();
1520 /* Anyone who cares about input state, wake up and do something */
1522 IOConnectionsComplete (); /* EMIT SIGNAL */
1524 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1526 /* now handle the whole enchilada as if it was one
1527 graph reorder event.
1532 /* update the full solo state, which can't be
1533 correctly determined on a per-route basis, but
1534 needs the global overview that only the session
1538 update_route_solo_state ();
1542 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1544 boost::shared_ptr<Track> track = wp.lock ();
1549 boost::shared_ptr<Playlist> playlist;
1551 if ((playlist = track->playlist()) != 0) {
1552 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1553 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1554 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1559 Session::record_enabling_legal () const
1561 /* this used to be in here, but survey says.... we don't need to restrict it */
1562 // if (record_status() == Recording) {
1566 if (Config->get_all_safe()) {
1573 Session::set_track_monitor_input_status (bool yn)
1575 boost::shared_ptr<RouteList> rl = routes.reader ();
1576 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1577 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1578 if (tr && tr->rec_enable_control()->get_value()) {
1579 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1580 tr->request_input_monitoring (yn);
1586 Session::auto_punch_start_changed (Location* location)
1588 replace_event (SessionEvent::PunchIn, location->start());
1590 if (get_record_enabled() && config.get_punch_in()) {
1591 /* capture start has been changed, so save new pending state */
1592 save_state ("", true);
1597 Session::auto_punch_end_changed (Location* location)
1599 framepos_t when_to_stop = location->end();
1600 // when_to_stop += _worst_output_latency + _worst_input_latency;
1601 replace_event (SessionEvent::PunchOut, when_to_stop);
1605 Session::auto_punch_changed (Location* location)
1607 framepos_t when_to_stop = location->end();
1609 replace_event (SessionEvent::PunchIn, location->start());
1610 //when_to_stop += _worst_output_latency + _worst_input_latency;
1611 replace_event (SessionEvent::PunchOut, when_to_stop);
1614 /** @param loc A loop location.
1615 * @param pos Filled in with the start time of the required fade-out (in session frames).
1616 * @param length Filled in with the length of the required fade-out.
1619 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1621 pos = max (loc->start(), loc->end() - 64);
1622 length = loc->end() - pos;
1626 Session::auto_loop_changed (Location* location)
1628 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1631 auto_loop_declick_range (location, dcp, dcl);
1633 if (transport_rolling() && play_loop) {
1635 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1637 // if (_transport_frame > location->end()) {
1639 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1640 // relocate to beginning of loop
1641 clear_events (SessionEvent::LocateRoll);
1643 request_locate (location->start(), true);
1646 else if (Config->get_seamless_loop() && !loop_changing) {
1648 // schedule a locate-roll to refill the diskstreams at the
1649 // previous loop end
1650 loop_changing = true;
1652 if (location->end() > last_loopend) {
1653 clear_events (SessionEvent::LocateRoll);
1654 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1660 clear_events (SessionEvent::AutoLoopDeclick);
1661 clear_events (SessionEvent::AutoLoop);
1664 /* possibly move playhead if not rolling; if we are rolling we'll move
1665 to the loop start on stop if that is appropriate.
1670 if (!transport_rolling() && select_playhead_priority_target (pos)) {
1671 if (pos == location->start()) {
1672 request_locate (pos);
1677 last_loopend = location->end();
1682 Session::set_auto_punch_location (Location* location)
1686 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1687 punch_connections.drop_connections();
1688 existing->set_auto_punch (false, this);
1689 remove_event (existing->start(), SessionEvent::PunchIn);
1690 clear_events (SessionEvent::PunchOut);
1691 auto_punch_location_changed (0);
1696 if (location == 0) {
1700 if (location->end() <= location->start()) {
1701 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1705 punch_connections.drop_connections ();
1707 location->StartChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, location));
1708 location->EndChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, location));
1709 location->Changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, location));
1711 location->set_auto_punch (true, this);
1713 auto_punch_changed (location);
1715 auto_punch_location_changed (location);
1719 Session::set_session_extents (framepos_t start, framepos_t end)
1722 if ((existing = _locations->session_range_location()) == 0) {
1723 //if there is no existing session, we need to make a new session location (should never happen)
1724 existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange, 0);
1728 error << _("Session: you can't use that location for session start/end)") << endmsg;
1732 existing->set( start, end );
1738 Session::set_auto_loop_location (Location* location)
1742 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1743 loop_connections.drop_connections ();
1744 existing->set_auto_loop (false, this);
1745 remove_event (existing->end(), SessionEvent::AutoLoop);
1748 auto_loop_declick_range (existing, dcp, dcl);
1749 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1750 auto_loop_location_changed (0);
1755 if (location == 0) {
1759 if (location->end() <= location->start()) {
1760 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1764 last_loopend = location->end();
1766 loop_connections.drop_connections ();
1768 location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1769 location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1770 location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1771 location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1773 location->set_auto_loop (true, this);
1775 if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
1776 // set all tracks to use internal looping
1777 boost::shared_ptr<RouteList> rl = routes.reader ();
1778 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1779 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1780 if (tr && !tr->hidden()) {
1781 tr->set_loop (location);
1786 /* take care of our stuff first */
1788 auto_loop_changed (location);
1790 /* now tell everyone else */
1792 auto_loop_location_changed (location);
1796 Session::update_marks (Location*)
1802 Session::update_skips (Location* loc, bool consolidate)
1804 if (_ignore_skips_updates) {
1808 Locations::LocationList skips;
1811 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1812 consolidate_skips (loc);
1815 sync_locations_to_skips ();
1821 Session::consolidate_skips (Location* loc)
1823 Locations::LocationList all_locations = _locations->list ();
1825 for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1827 if (!(*l)->is_skip ()) {
1832 /* don't test against self */
1839 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1840 case Evoral::OverlapInternal:
1841 case Evoral::OverlapExternal:
1842 case Evoral::OverlapStart:
1843 case Evoral::OverlapEnd:
1844 /* adjust new location to cover existing one */
1845 loc->set_start (min (loc->start(), (*l)->start()));
1846 loc->set_end (max (loc->end(), (*l)->end()));
1847 /* we don't need this one any more */
1848 _locations->remove (*l);
1849 /* the location has been deleted, so remove reference to it in our local list */
1850 l = all_locations.erase (l);
1853 case Evoral::OverlapNone:
1861 Session::sync_locations_to_skips ()
1863 /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1864 * Session::_sync_locations_to_skips() from the audioengine thread.
1866 clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1870 Session::_sync_locations_to_skips ()
1872 /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1874 Locations::LocationList const & locs (_locations->list());
1876 for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1878 Location* location = *i;
1880 if (location->is_skip() && location->is_skipping()) {
1881 SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1889 Session::location_added (Location *location)
1891 if (location->is_auto_punch()) {
1892 set_auto_punch_location (location);
1895 if (location->is_auto_loop()) {
1896 set_auto_loop_location (location);
1899 if (location->is_session_range()) {
1900 /* no need for any signal handling or event setting with the session range,
1901 because we keep a direct reference to it and use its start/end directly.
1903 _session_range_location = location;
1906 if (location->is_mark()) {
1907 /* listen for per-location signals that require us to do any * global updates for marks */
1909 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1910 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1911 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1912 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1913 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1916 if (location->is_range_marker()) {
1917 /* listen for per-location signals that require us to do any * global updates for marks */
1919 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1920 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1921 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1922 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1923 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1926 if (location->is_skip()) {
1927 /* listen for per-location signals that require us to update skip-locate events */
1929 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1930 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1931 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1932 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
1933 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1935 update_skips (location, true);
1942 Session::location_removed (Location *location)
1944 if (location->is_auto_loop()) {
1945 set_auto_loop_location (0);
1946 set_track_loop (false);
1949 if (location->is_auto_punch()) {
1950 set_auto_punch_location (0);
1953 if (location->is_session_range()) {
1954 /* this is never supposed to happen */
1955 error << _("programming error: session range removed!") << endl;
1958 if (location->is_skip()) {
1960 update_skips (location, false);
1967 Session::locations_changed ()
1969 _locations->apply (*this, &Session::_locations_changed);
1973 Session::_locations_changed (const Locations::LocationList& locations)
1975 /* There was some mass-change in the Locations object.
1977 We might be re-adding a location here but it doesn't actually matter
1978 for all the locations that the Session takes an interest in.
1982 PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
1983 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1984 location_added (*i);
1988 update_skips (NULL, false);
1992 Session::enable_record ()
1994 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1995 /* no recording at anything except normal speed */
2000 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
2002 if (rs == Recording) {
2006 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
2008 _last_record_location = _transport_frame;
2009 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
2011 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2012 set_track_monitor_input_status (true);
2015 RecordStateChanged ();
2022 Session::set_all_tracks_record_enabled (bool enable )
2024 boost::shared_ptr<RouteList> rl = routes.reader();
2025 set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), enable, Controllable::NoGroup);
2029 Session::disable_record (bool rt_context, bool force)
2033 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
2035 if (!Config->get_latched_record_enable () || force) {
2036 g_atomic_int_set (&_record_status, Disabled);
2037 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
2039 if (rs == Recording) {
2040 g_atomic_int_set (&_record_status, Enabled);
2044 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2045 set_track_monitor_input_status (false);
2048 RecordStateChanged (); /* emit signal */
2051 remove_pending_capture_state ();
2053 unset_preroll_record_punch ();
2058 Session::step_back_from_record ()
2060 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
2062 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2063 set_track_monitor_input_status (false);
2066 RecordStateChanged (); /* emit signal */
2071 Session::maybe_enable_record (bool rt_context)
2073 if (_step_editors > 0) {
2077 g_atomic_int_set (&_record_status, Enabled);
2079 /* This function is currently called from somewhere other than an RT thread.
2080 * (except maybe lua scripts, which can use rt_context = true)
2081 * This save_state() call therefore doesn't impact anything. Doing it here
2082 * means that we save pending state of which sources the next record will use,
2083 * which gives us some chance of recovering from a crash during the record.
2087 save_state ("", true);
2090 if (_transport_speed) {
2091 if (!config.get_punch_in() && !preroll_record_punch_enabled ()) {
2095 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
2096 RecordStateChanged (); /* EMIT SIGNAL */
2103 Session::audible_frame (bool* latent_locate) const
2107 frameoffset_t offset = worst_playback_latency (); // - _engine.samples_since_cycle_start ();
2108 offset *= transport_speed ();
2109 if (latent_locate) {
2110 *latent_locate = false;
2113 if (synced_to_engine()) {
2114 /* Note: this is basically just sync-to-JACK */
2115 ret = _engine.transport_frame();
2117 ret = _transport_frame;
2120 if (transport_rolling()) {
2123 /* Check to see if we have passed the first guaranteed
2124 * audible frame past our last start position. if not,
2125 * return that last start point because in terms
2126 * of audible frames, we have not moved yet.
2128 * `Start position' in this context means the time we last
2129 * either started, located, or changed transport direction.
2132 if (_transport_speed > 0.0f) {
2134 if (!play_loop || !have_looped) {
2135 if (ret < _last_roll_or_reversal_location) {
2136 if (latent_locate) {
2137 *latent_locate = true;
2139 return _last_roll_or_reversal_location;
2142 /* the play-position wrapped at the loop-point
2143 * ardour is already playing the beginning of the loop,
2144 * but due to playback latency, the "audible frame"
2145 * is still at the end of the loop.
2147 Location *location = _locations->auto_loop_location();
2148 frameoffset_t lo = location->start() - ret;
2150 ret = location->end () - lo;
2151 if (latent_locate) {
2152 *latent_locate = true;
2157 } else if (_transport_speed < 0.0f) {
2159 /* XXX wot? no backward looping? */
2161 if (ret > _last_roll_or_reversal_location) {
2162 return _last_roll_or_reversal_location;
2167 return std::max ((framepos_t)0, ret);
2172 Session::preroll_samples (framepos_t pos) const
2174 const float pr = Config->get_preroll_seconds();
2175 if (pos >= 0 && pr < 0) {
2176 const Tempo& tempo = _tempo_map->tempo_at_frame (pos);
2177 const Meter& meter = _tempo_map->meter_at_frame (pos);
2178 return meter.frames_per_bar (tempo, frame_rate()) * -pr;
2183 return pr * frame_rate();
2187 Session::set_frame_rate (framecnt_t frames_per_second)
2189 /** \fn void Session::set_frame_size(framecnt_t)
2190 the AudioEngine object that calls this guarantees
2191 that it will not be called while we are also in
2192 ::process(). Its fine to do things that block
2196 if (_base_frame_rate == 0) {
2197 _base_frame_rate = frames_per_second;
2199 else if (_base_frame_rate != frames_per_second && frames_per_second != _nominal_frame_rate) {
2200 NotifyAboutSampleRateMismatch (_base_frame_rate, frames_per_second);
2202 _nominal_frame_rate = frames_per_second;
2207 reset_write_sources (false);
2209 // XXX we need some equivalent to this, somehow
2210 // SndFileSource::setup_standard_crossfades (frames_per_second);
2214 /* XXX need to reset/reinstantiate all LADSPA plugins */
2218 Session::set_block_size (pframes_t nframes)
2220 /* the AudioEngine guarantees
2221 that it will not be called while we are also in
2222 ::process(). It is therefore fine to do things that block
2227 current_block_size = nframes;
2231 boost::shared_ptr<RouteList> r = routes.reader ();
2233 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2234 (*i)->set_block_size (nframes);
2237 boost::shared_ptr<RouteList> rl = routes.reader ();
2238 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2239 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2241 tr->set_block_size (nframes);
2245 set_worst_io_latencies ();
2251 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2253 boost::shared_ptr<Route> r2;
2255 if (r1->feeds (rbase) && rbase->feeds (r1)) {
2256 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2260 /* make a copy of the existing list of routes that feed r1 */
2262 Route::FedBy existing (r1->fed_by());
2264 /* for each route that feeds r1, recurse, marking it as feeding
2268 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2269 if (!(r2 = i->r.lock ())) {
2270 /* (*i) went away, ignore it */
2274 /* r2 is a route that feeds r1 which somehow feeds base. mark
2275 base as being fed by r2
2278 rbase->add_fed_by (r2, i->sends_only);
2282 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2286 if (r1->feeds (r2) && r2->feeds (r1)) {
2290 /* now recurse, so that we can mark base as being fed by
2291 all routes that feed r2
2294 trace_terminal (r2, rbase);
2301 Session::resort_routes ()
2303 /* don't do anything here with signals emitted
2304 by Routes during initial setup or while we
2305 are being destroyed.
2308 if (_state_of_the_state & (InitialConnecting | Deletion)) {
2312 if (_route_deletion_in_progress) {
2317 RCUWriter<RouteList> writer (routes);
2318 boost::shared_ptr<RouteList> r = writer.get_copy ();
2319 resort_routes_using (r);
2320 /* writer goes out of scope and forces update */
2324 if (DEBUG_ENABLED(DEBUG::Graph)) {
2325 boost::shared_ptr<RouteList> rl = routes.reader ();
2326 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2327 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2329 const Route::FedBy& fb ((*i)->fed_by());
2331 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2332 boost::shared_ptr<Route> sf = f->r.lock();
2334 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2343 /** This is called whenever we need to rebuild the graph of how we will process
2345 * @param r List of routes, in any order.
2349 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2351 /* We are going to build a directed graph of our routes;
2352 this is where the edges of that graph are put.
2357 /* Go through all routes doing two things:
2359 * 1. Collect the edges of the route graph. Each of these edges
2360 * is a pair of routes, one of which directly feeds the other
2361 * either by a JACK connection or by an internal send.
2363 * 2. Begin the process of making routes aware of which other
2364 * routes directly or indirectly feed them. This information
2365 * is used by the solo code.
2368 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2370 /* Clear out the route's list of direct or indirect feeds */
2371 (*i)->clear_fed_by ();
2373 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2375 bool via_sends_only;
2377 /* See if this *j feeds *i according to the current state of the JACK
2378 connections and internal sends.
2380 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2381 /* add the edge to the graph (part #1) */
2382 edges.add (*j, *i, via_sends_only);
2383 /* tell the route (for part #2) */
2384 (*i)->add_fed_by (*j, via_sends_only);
2389 /* Attempt a topological sort of the route graph */
2390 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2392 if (sorted_routes) {
2393 /* We got a satisfactory topological sort, so there is no feedback;
2396 Note: the process graph rechain does not require a
2397 topologically-sorted list, but hey ho.
2399 if (_process_graph) {
2400 _process_graph->rechain (sorted_routes, edges);
2403 _current_route_graph = edges;
2405 /* Complete the building of the routes' lists of what directly
2406 or indirectly feeds them.
2408 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2409 trace_terminal (*i, *i);
2412 *r = *sorted_routes;
2415 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2416 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2417 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
2421 SuccessfulGraphSort (); /* EMIT SIGNAL */
2424 /* The topological sort failed, so we have a problem. Tell everyone
2425 and stick to the old graph; this will continue to be processed, so
2426 until the feedback is fixed, what is played back will not quite
2427 reflect what is actually connected. Note also that we do not
2428 do trace_terminal here, as it would fail due to an endless recursion,
2429 so the solo code will think that everything is still connected
2433 FeedbackDetected (); /* EMIT SIGNAL */
2438 /** Find a route name starting with \a base, maybe followed by the
2439 * lowest \a id. \a id will always be added if \a definitely_add_number
2440 * is true on entry; otherwise it will only be added if required
2441 * to make the name unique.
2443 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2444 * The available route name with the lowest ID will be used, and \a id
2445 * will be set to the ID.
2447 * \return false if a route name could not be found, and \a track_name
2448 * and \a id do not reflect a free route name.
2451 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2453 /* the base may conflict with ports that do not belong to existing
2454 routes, but hidden objects like the click track. So check port names
2455 before anything else.
2458 for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2459 if (base == reserved->first) {
2460 /* Check if this reserved name already exists, and if
2461 so, disallow it without a numeric suffix.
2463 if (!reserved->second || route_by_name (reserved->first)) {
2464 definitely_add_number = true;
2473 /* if we have "base 1" already, it doesn't make sense to add "base"
2474 * if "base 1" has been deleted, adding "base" is no worse than "base 1"
2476 if (!definitely_add_number && route_by_name (base) == 0 && (route_by_name (string_compose("%1 1", base)) == 0)) {
2477 /* just use the base */
2483 name = string_compose ("%1 %2", base, id);
2485 if (route_by_name (name) == 0) {
2491 } while (id < (UINT_MAX-1));
2496 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2498 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2500 in = ChanCount::ZERO;
2501 out = ChanCount::ZERO;
2503 boost::shared_ptr<RouteList> r = routes.reader ();
2505 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2506 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2507 if (tr && !tr->is_auditioner()) {
2508 in += tr->n_inputs();
2509 out += tr->n_outputs();
2515 Session::default_track_name_pattern (DataType t)
2518 case DataType::AUDIO:
2519 if (Profile->get_trx()) {
2526 case DataType::MIDI:
2533 /** Caller must not hold process lock
2534 * @param name_template string to use for the start of the name, or "" to use "MIDI".
2535 * @param instrument plugin info for the instrument to insert pre-fader, if any
2537 list<boost::shared_ptr<MidiTrack> >
2538 Session::new_midi_track (const ChanCount& input, const ChanCount& output, bool strict_io,
2539 boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2540 RouteGroup* route_group, uint32_t how_many,
2541 string name_template, PresentationInfo::order_t order,
2545 uint32_t track_id = 0;
2547 RouteList new_routes;
2548 list<boost::shared_ptr<MidiTrack> > ret;
2550 const string name_pattern = default_track_name_pattern (DataType::MIDI);
2551 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2554 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2555 error << "cannot find name for new midi track" << endmsg;
2559 boost::shared_ptr<MidiTrack> track;
2562 track.reset (new MidiTrack (*this, track_name, mode));
2564 if (track->init ()) {
2569 track->set_strict_io (true);
2572 track->use_new_diskstream();
2574 BOOST_MARK_TRACK (track);
2577 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2578 if (track->input()->ensure_io (input, false, this)) {
2579 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2583 if (track->output()->ensure_io (output, false, this)) {
2584 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2589 track->non_realtime_input_change();
2592 route_group->add (track);
2595 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2597 new_routes.push_back (track);
2598 ret.push_back (track);
2601 catch (failed_constructor &err) {
2602 error << _("Session: could not create new midi track.") << endmsg;
2606 catch (AudioEngine::PortRegistrationFailure& pfe) {
2608 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;
2616 if (!new_routes.empty()) {
2617 StateProtector sp (this);
2618 if (Profile->get_trx()) {
2619 add_routes (new_routes, false, false, false, order);
2621 add_routes (new_routes, true, true, false, order);
2625 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2626 PluginPtr plugin = instrument->load (*this);
2628 warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2632 plugin->load_preset (*pset);
2634 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2636 pi->set_strict_io (true);
2639 (*r)->add_processor (pi, PreFader);
2641 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2642 (*r)->move_instrument_down (false);
2652 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, bool strict_io,
2653 boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2654 PresentationInfo::Flag flag, PresentationInfo::order_t order)
2657 uint32_t bus_id = 0;
2661 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2664 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2665 error << "cannot find name for new midi bus" << endmsg;
2670 boost::shared_ptr<Route> bus (new Route (*this, bus_name, flag, DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2677 bus->set_strict_io (true);
2680 BOOST_MARK_ROUTE(bus);
2683 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2685 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2686 error << _("cannot configure new midi bus input") << endmsg;
2691 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2692 error << _("cannot configure new midi bus output") << endmsg;
2698 route_group->add (bus);
2701 bus->add_internal_return ();
2702 ret.push_back (bus);
2705 catch (failed_constructor &err) {
2706 error << _("Session: could not create new audio route.") << endmsg;
2710 catch (AudioEngine::PortRegistrationFailure& pfe) {
2711 error << pfe.what() << endmsg;
2721 StateProtector sp (this);
2722 add_routes (ret, false, false, false, order);
2725 for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2726 PluginPtr plugin = instrument->load (*this);
2728 warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2732 plugin->load_preset (*pset);
2734 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2736 pi->set_strict_io (true);
2739 (*r)->add_processor (pi, PreFader);
2741 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2742 (*r)->move_instrument_down (false);
2754 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2756 boost::shared_ptr<Route> midi_track (wmt.lock());
2762 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2764 if (change.after.n_audio() <= change.before.n_audio()) {
2768 /* new audio ports: make sure the audio goes somewhere useful,
2769 * unless the user has no-auto-connect selected.
2771 * The existing ChanCounts don't matter for this call as they are only
2772 * to do with matching input and output indices, and we are only changing
2775 auto_connect_route (midi_track, false, ChanCount(), change.before);
2779 #ifdef USE_TRACKS_CODE_FEATURES
2782 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2784 return route1->remote_control_id() < route2->remote_control_id();
2788 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2790 // it is not allowed to perform connection
2791 if (!IO::connecting_legal) {
2795 // if we are deleting routes we will call this once at the end
2796 if (_route_deletion_in_progress) {
2800 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2806 // We need to disconnect the route's inputs and outputs first
2807 // basing on autoconnect configuration
2808 bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2809 bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2811 ChanCount existing_inputs;
2812 ChanCount existing_outputs;
2813 count_existing_track_channels (existing_inputs, existing_outputs);
2815 //ChanCount inputs = ChanCount::ZERO;
2816 //ChanCount outputs = ChanCount::ZERO;
2818 RouteList existing_routes = *routes.reader ();
2819 existing_routes.sort (compare_routes_by_remote_id);
2822 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2824 vector<string> physinputs;
2825 vector<string> physoutputs;
2827 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2828 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2830 uint32_t input_n = 0;
2831 uint32_t output_n = 0;
2832 RouteList::iterator rIter = existing_routes.begin();
2833 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2834 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2835 for (; rIter != existing_routes.end(); ++rIter) {
2836 if (*rIter == _master_out || *rIter == _monitor_out ) {
2840 if (current_output_auto_connection == AutoConnectPhysical) {
2841 (*rIter)->amp()->deactivate();
2842 } else if (current_output_auto_connection == AutoConnectMaster) {
2843 (*rIter)->amp()->activate();
2846 if (reconnectIputs) {
2847 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2849 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2851 if (current_input_auto_connection & AutoConnectPhysical) {
2853 if ( input_n == physinputs.size() ) {
2857 string port = physinputs[input_n];
2859 if (port.empty() ) {
2860 error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2863 //GZ: check this; could be heavy
2864 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2870 if (reconnectOutputs) {
2872 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2873 if (current_output_auto_connection & AutoConnectPhysical) {
2875 //GZ: check this; could be heavy
2876 (*rIter)->output()->disconnect (this);
2877 size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2879 //GZ: check this; could be heavy
2880 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2882 } else if (current_output_auto_connection & AutoConnectMaster){
2884 if (!reconnect_master) {
2888 //GZ: check this; could be heavy
2889 (*rIter)->output()->disconnect (this);
2892 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2893 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2895 error << error << "Master bus is not available" << endmsg;
2900 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2901 if (current_output_auto_connection & AutoConnectPhysical) {
2903 if ( output_n == physoutputs.size() ) {
2907 string port = physoutputs[output_n];
2909 if (port.empty() ) {
2910 error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2913 //GZ: check this; could be heavy
2914 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2917 } else if (current_output_auto_connection & AutoConnectMaster) {
2919 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2923 // connect to master bus
2924 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2926 if (port.empty() ) {
2927 error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2931 //GZ: check this; could be heavy
2932 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2939 _master_out->output()->disconnect (this);
2940 auto_connect_master_bus ();
2945 session_routes_reconnected (); /* EMIT SIGNAL */
2949 Session::reconnect_midi_scene_ports(bool inputs)
2953 boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2955 scene_in_ptr->disconnect_all ();
2957 std::vector<EngineStateController::MidiPortState> midi_port_states;
2958 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2960 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2962 for (; state_iter != midi_port_states.end(); ++state_iter) {
2963 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2964 scene_in_ptr->connect (state_iter->name);
2971 boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2973 if (scene_out_ptr ) {
2974 scene_out_ptr->disconnect_all ();
2976 std::vector<EngineStateController::MidiPortState> midi_port_states;
2977 EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2979 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2981 for (; state_iter != midi_port_states.end(); ++state_iter) {
2982 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2983 scene_out_ptr->connect (state_iter->name);
2991 Session::reconnect_mtc_ports ()
2993 boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
2999 mtc_in_ptr->disconnect_all ();
3001 std::vector<EngineStateController::MidiPortState> midi_port_states;
3002 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
3004 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3006 for (; state_iter != midi_port_states.end(); ++state_iter) {
3007 if (state_iter->available && state_iter->mtc_in) {
3008 mtc_in_ptr->connect (state_iter->name);
3012 if (!_midi_ports->mtc_input_port ()->connected () &&
3013 config.get_external_sync () &&
3014 (Config->get_sync_source () == MTC) ) {
3015 config.set_external_sync (false);
3018 if ( ARDOUR::Profile->get_trx () ) {
3019 // Tracks need this signal to update timecode_source_dropdown
3020 MtcOrLtcInputPortChanged (); //emit signal
3025 Session::reconnect_mmc_ports(bool inputs)
3027 if (inputs ) { // get all enabled midi input ports
3029 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
3031 mmc_in_ptr->disconnect_all ();
3032 std::vector<std::string> enabled_midi_inputs;
3033 EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
3035 std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
3037 for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
3038 mmc_in_ptr->connect (*port_iter);
3042 } else { // get all enabled midi output ports
3044 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
3046 mmc_out_ptr->disconnect_all ();
3047 std::vector<std::string> enabled_midi_outputs;
3048 EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
3050 std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
3052 for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
3053 mmc_out_ptr->connect (*port_iter);
3062 Session::ensure_stripable_sort_order ()
3065 get_stripables (sl);
3066 sl.sort (Stripable::Sorter ());
3068 bool change = false;
3069 PresentationInfo::order_t order = 0;
3071 for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3072 boost::shared_ptr<Stripable> s (*si);
3073 if (s->is_monitor () || s->is_auditioner ()) {
3076 if (order != s->presentation_info().order()) {
3077 s->set_presentation_order (order);
3086 Session::ensure_route_presentation_info_gap (PresentationInfo::order_t first_new_order, uint32_t how_many)
3088 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("ensure order gap starting at %1 for %2\n", first_new_order, how_many));
3090 if (first_new_order == PresentationInfo::max_order) {
3091 /* adding at end, no worries */
3095 /* create a gap in the presentation info to accomodate @param how_many
3099 get_stripables (sl);
3101 for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3102 boost::shared_ptr<Stripable> s (*si);
3104 if (s->presentation_info().special (false)) {
3108 if (!s->presentation_info().order_set()) {
3112 if (s->presentation_info().order () >= first_new_order) {
3113 s->set_presentation_order (s->presentation_info().order () + how_many);
3118 /** Caller must not hold process lock
3119 * @param name_template string to use for the start of the name, or "" to use "Audio".
3121 list< boost::shared_ptr<AudioTrack> >
3122 Session::new_audio_track (int input_channels, int output_channels, RouteGroup* route_group,
3123 uint32_t how_many, string name_template, PresentationInfo::order_t order,
3127 uint32_t track_id = 0;
3129 RouteList new_routes;
3130 list<boost::shared_ptr<AudioTrack> > ret;
3132 const string name_pattern = default_track_name_pattern (DataType::AUDIO);
3133 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
3137 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
3138 error << "cannot find name for new audio track" << endmsg;
3142 boost::shared_ptr<AudioTrack> track;
3145 track.reset (new AudioTrack (*this, track_name, mode));
3147 if (track->init ()) {
3151 if (Profile->get_mixbus ()) {
3152 track->set_strict_io (true);
3155 if (ARDOUR::Profile->get_trx ()) {
3156 // TRACKS considers it's not a USE CASE, it's
3157 // a piece of behavior of the session model:
3159 // Gain for a newly created route depends on
3160 // the current output_auto_connect mode:
3162 // 0 for Stereo Out mode
3164 if (Config->get_output_auto_connect() & AutoConnectMaster) {
3165 track->gain_control()->set_value (dB_to_coefficient (0), Controllable::NoGroup);
3169 track->use_new_diskstream();
3171 BOOST_MARK_TRACK (track);
3174 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3176 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3177 error << string_compose (
3178 _("cannot configure %1 in/%2 out configuration for new audio track"),
3179 input_channels, output_channels)
3184 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3185 error << string_compose (
3186 _("cannot configure %1 in/%2 out configuration for new audio track"),
3187 input_channels, output_channels)
3194 route_group->add (track);
3197 track->non_realtime_input_change();
3199 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
3201 new_routes.push_back (track);
3202 ret.push_back (track);
3205 catch (failed_constructor &err) {
3206 error << _("Session: could not create new audio track.") << endmsg;
3210 catch (AudioEngine::PortRegistrationFailure& pfe) {
3212 error << pfe.what() << endmsg;
3220 if (!new_routes.empty()) {
3221 StateProtector sp (this);
3222 if (Profile->get_trx()) {
3223 add_routes (new_routes, false, false, false, order);
3225 add_routes (new_routes, true, true, false, order);
3232 /** Caller must not hold process lock.
3233 * @param name_template string to use for the start of the name, or "" to use "Bus".
3236 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template,
3237 PresentationInfo::Flag flags, PresentationInfo::order_t order)
3240 uint32_t bus_id = 0;
3244 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3247 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3248 error << "cannot find name for new audio bus" << endmsg;
3253 boost::shared_ptr<Route> bus (new Route (*this, bus_name, flags, DataType::AUDIO));
3259 if (Profile->get_mixbus ()) {
3260 bus->set_strict_io (true);
3263 BOOST_MARK_ROUTE(bus);
3266 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3268 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3269 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3270 input_channels, output_channels)
3276 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3277 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3278 input_channels, output_channels)
3285 route_group->add (bus);
3288 bus->add_internal_return ();
3289 ret.push_back (bus);
3292 catch (failed_constructor &err) {
3293 error << _("Session: could not create new audio route.") << endmsg;
3297 catch (AudioEngine::PortRegistrationFailure& pfe) {
3298 error << pfe.what() << endmsg;
3308 StateProtector sp (this);
3309 if (Profile->get_trx()) {
3310 add_routes (ret, false, false, false, order);
3312 add_routes (ret, false, true, true, order); // autoconnect // outputs only
3321 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
3322 PlaylistDisposition pd)
3326 if (!tree.read (template_path.c_str())) {
3330 return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
3334 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3337 uint32_t number = 0;
3338 const uint32_t being_added = how_many;
3339 /* This will prevent the use of any existing XML-provided PBD::ID
3342 Stateful::ForceIDRegeneration force_ids;
3343 IO::disable_connecting ();
3347 /* We're going to modify the node contents a bit so take a
3348 * copy. The node may be re-used when duplicating more than once.
3351 XMLNode node_copy (node);
3356 if (!name_base.empty()) {
3358 /* if we're adding more than one routes, force
3359 * all the names of the new routes to be
3360 * numbered, via the final parameter.
3363 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3364 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3370 string const route_name = node_copy.property(X_("name"))->value ();
3372 /* generate a new name by adding a number to the end of the template name */
3373 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3374 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3375 abort(); /*NOTREACHED*/
3379 /* set this name in the XML description that we are about to use */
3381 if (pd == CopyPlaylist) {
3382 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3384 const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3385 boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3386 // Use same name as Route::set_name_in_state so playlist copy
3387 // is picked up when creating the Route in XMLRouteFactory below
3388 playlist = PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3389 playlist->reset_shares ();
3391 } else if (pd == SharePlaylist) {
3392 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3394 const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3395 boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3396 playlist->share_with ((node_copy.property (X_("id")))->value());
3400 bool rename_playlist = (pd == CopyPlaylist || pd == NewPlaylist);
3402 Route::set_name_in_state (node_copy, name, rename_playlist);
3404 /* trim bitslots from listen sends so that new ones are used */
3405 XMLNodeList children = node_copy.children ();
3406 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3407 if ((*i)->name() == X_("Processor")) {
3408 /* ForceIDRegeneration does not catch the following */
3409 XMLProperty const * role = (*i)->property (X_("role"));
3410 XMLProperty const * type = (*i)->property (X_("type"));
3411 if (role && role->value() == X_("Aux")) {
3412 /* check if the target bus exists.
3413 * we should not save aux-sends in templates.
3415 XMLProperty const * target = (*i)->property (X_("target"));
3417 (*i)->set_property ("type", "dangling-aux-send");
3420 boost::shared_ptr<Route> r = route_by_id (target->value());
3421 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3422 (*i)->set_property ("type", "dangling-aux-send");
3426 if (role && role->value() == X_("Listen")) {
3427 (*i)->remove_property (X_("bitslot"));
3429 else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3430 Delivery::Role xrole;
3431 uint32_t bitslot = 0;
3432 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3433 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3434 (*i)->remove_property (X_("bitslot"));
3435 (*i)->remove_property (X_("name"));
3436 (*i)->set_property ("bitslot", bitslot);
3437 (*i)->set_property ("name", name);
3439 else if (type && type->value() == X_("intreturn")) {
3440 (*i)->remove_property (X_("bitslot"));
3441 (*i)->set_property ("ignore-bitslot", "1");
3443 else if (type && type->value() == X_("return")) {
3444 // Return::set_state() generates a new one
3445 (*i)->remove_property (X_("bitslot"));
3447 else if (type && type->value() == X_("port")) {
3448 // PortInsert::set_state() handles the bitslot
3449 (*i)->remove_property (X_("bitslot"));
3450 (*i)->set_property ("ignore-name", "1");
3455 /* new routes start off unsoloed to avoid issues related to
3456 upstream / downstream buses. */
3457 node_copy.remove_node_and_delete (X_("Controllable"), X_("name"), X_("solo"));
3459 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3462 error << _("Session: cannot create track/bus from template description") << endmsg;
3466 if (boost::dynamic_pointer_cast<Track>(route)) {
3467 /* force input/output change signals so that the new diskstream
3468 picks up the configuration of the route. During session
3469 loading this normally happens in a different way.
3472 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3474 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3475 change.after = route->input()->n_ports();
3476 route->input()->changed (change, this);
3477 change.after = route->output()->n_ports();
3478 route->output()->changed (change, this);
3481 ret.push_back (route);
3484 catch (failed_constructor &err) {
3485 error << _("Session: could not create new route from template") << endmsg;
3489 catch (AudioEngine::PortRegistrationFailure& pfe) {
3490 error << pfe.what() << endmsg;
3499 StateProtector sp (this);
3500 if (Profile->get_trx()) {
3501 add_routes (ret, false, false, false, insert_at);
3503 add_routes (ret, true, true, false, insert_at);
3505 IO::enable_connecting ();
3512 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3515 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3516 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3519 error << _("Adding new tracks/busses failed") << endmsg;
3524 update_latency (true);
3525 update_latency (false);
3530 save_state (_current_snapshot_name);
3533 update_route_record_state ();
3535 RouteAdded (new_routes); /* EMIT SIGNAL */
3539 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3541 ChanCount existing_inputs;
3542 ChanCount existing_outputs;
3546 count_existing_track_channels (existing_inputs, existing_outputs);
3549 RCUWriter<RouteList> writer (routes);
3550 boost::shared_ptr<RouteList> r = writer.get_copy ();
3551 n_routes = r->size();
3552 r->insert (r->end(), new_routes.begin(), new_routes.end());
3554 /* if there is no control out and we're not in the middle of loading,
3555 * resort the graph here. if there is a control out, we will resort
3556 * toward the end of this method. if we are in the middle of loading,
3557 * we will resort when done.
3560 if (!_monitor_out && IO::connecting_legal) {
3561 resort_routes_using (r);
3565 /* auditioner and monitor routes are not part of the order */
3567 assert (n_routes > 0);
3571 assert (n_routes > 0);
3576 PresentationInfo::ChangeSuspender cs;
3577 ensure_route_presentation_info_gap (order, new_routes.size());
3579 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3581 boost::weak_ptr<Route> wpr (*x);
3582 boost::shared_ptr<Route> r (*x);
3584 r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3585 r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3586 r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3588 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3589 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3590 r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3592 if (r->is_master()) {
3596 if (r->is_monitor()) {
3600 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3602 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3603 track_playlist_changed (boost::weak_ptr<Track> (tr));
3604 tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3606 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3608 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3609 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3610 mt->presentation_info().PropertyChanged.connect_same_thread (*this, boost::bind (&Session::midi_track_presentation_info_changed, this, _1, boost::weak_ptr<MidiTrack>(mt)));
3614 if (!r->presentation_info().special (false)) {
3616 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3618 /* presentation info order may already have been set from XML */
3620 if (!r->presentation_info().order_set()) {
3621 if (order == PresentationInfo::max_order) {
3622 /* just add to the end */
3623 r->set_presentation_order (n_routes + added);
3624 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3626 r->set_presentation_order (order + added);
3627 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3630 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3634 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3635 /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3636 * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3638 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3640 r->presentation_info().order(),
3641 enum_2_string (r->presentation_info().flags()),
3642 r->presentation_info()));
3646 if (input_auto_connect || output_auto_connect) {
3647 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3648 existing_inputs += r->n_inputs();
3649 existing_outputs += r->n_outputs();
3654 ensure_stripable_sort_order ();
3657 if (_monitor_out && IO::connecting_legal) {
3658 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3660 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3661 if ((*x)->is_monitor()) {
3663 } else if ((*x)->is_master()) {
3666 (*x)->enable_monitor_send ();
3671 reassign_track_numbers ();
3675 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3677 boost::shared_ptr<RouteList> r = routes.reader ();
3678 boost::shared_ptr<Send> s;
3680 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3681 if ((s = (*i)->internal_send_for (dest)) != 0) {
3682 s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3688 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3690 boost::shared_ptr<RouteList> r = routes.reader ();
3691 boost::shared_ptr<Send> s;
3693 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3694 if ((s = (*i)->internal_send_for (dest)) != 0) {
3695 s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3701 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3703 boost::shared_ptr<RouteList> r = routes.reader ();
3704 boost::shared_ptr<Send> s;
3706 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3707 if ((s = (*i)->internal_send_for (dest)) != 0) {
3708 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3713 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3715 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3717 boost::shared_ptr<RouteList> r = routes.reader ();
3718 boost::shared_ptr<RouteList> t (new RouteList);
3720 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3721 /* no MIDI sends because there are no MIDI busses yet */
3722 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3727 add_internal_sends (dest, p, t);
3731 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3733 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3734 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3739 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3741 add_internal_send (dest, sender->before_processor_for_index (index), sender);
3745 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3747 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3751 if (!dest->internal_return()) {
3752 dest->add_internal_return ();
3755 sender->add_aux_send (dest, before);
3761 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3763 bool mute_changed = false;
3764 bool send_selected = false;
3766 { // RCU Writer scope
3767 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3768 RCUWriter<RouteList> writer (routes);
3769 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3771 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3773 if (_selection->selected (*iter)) {
3774 send_selected = true;
3777 if (*iter == _master_out) {
3781 /* speed up session deletion, don't do the solo dance */
3782 if (0 == (_state_of_the_state & Deletion)) {
3783 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3786 if ((*iter)->mute_control()->muted ()) {
3787 mute_changed = true;
3792 /* deleting the master out seems like a dumb
3793 idea, but its more of a UI policy issue
3797 if (*iter == _master_out) {
3798 _master_out = boost::shared_ptr<Route> ();
3801 if (*iter == _monitor_out) {
3802 _monitor_out.reset ();
3805 // We need to disconnect the route's inputs and outputs
3807 (*iter)->input()->disconnect (0);
3808 (*iter)->output()->disconnect (0);
3810 /* if the route had internal sends sending to it, remove them */
3811 if ((*iter)->internal_return()) {
3813 boost::shared_ptr<RouteList> r = routes.reader ();
3814 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3815 boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3817 (*i)->remove_processor (s);
3822 /* if the monitoring section had a pointer to this route, remove it */
3823 if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3824 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3825 ProcessorChangeBlocker pcb (this, false);
3826 (*iter)->remove_aux_or_listen (_monitor_out);
3829 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3830 if (mt && mt->step_editing()) {
3831 if (_step_editors > 0) {
3837 /* writer goes out of scope, forces route list update */
3839 } // end of RCU Writer scope
3842 MuteChanged (); /* EMIT SIGNAL */
3845 update_route_solo_state ();
3846 update_latency_compensation ();
3849 /* Re-sort routes to remove the graph's current references to the one that is
3850 * going away, then flush old references out of the graph.
3851 * Wave Tracks: reconnect routes
3854 #ifdef USE_TRACKS_CODE_FEATURES
3855 reconnect_existing_routes(true, false);
3857 routes.flush (); // maybe unsafe, see below.
3861 if (_process_graph && !(_state_of_the_state & Deletion)) {
3862 _process_graph->clear_other_chain ();
3865 /* get rid of it from the dead wood collection in the route list manager */
3866 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3870 /* remove these routes from the selection if appropriate, and signal
3871 * the change *before* we call DropReferences for them.
3874 if (send_selected && !deletion_in_progress()) {
3875 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3876 _selection->remove_stripable_by_id ((*iter)->id());
3879 pc.add (Properties::selected);
3880 PresentationInfo::Change (pc);
3883 /* try to cause everyone to drop their references
3884 * and unregister ports from the backend
3887 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3888 (*iter)->drop_references ();
3891 if (deletion_in_progress()) {
3896 pc.add (Properties::order);
3897 PresentationInfo::Change (pc);
3899 /* save the new state of the world */
3901 if (save_state (_current_snapshot_name)) {
3902 save_history (_current_snapshot_name);
3905 update_route_record_state ();
3909 Session::remove_route (boost::shared_ptr<Route> route)
3911 boost::shared_ptr<RouteList> rl (new RouteList);
3912 rl->push_back (route);
3917 Session::route_mute_changed ()
3919 MuteChanged (); /* EMIT SIGNAL */
3924 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3926 boost::shared_ptr<Route> route (wpr.lock());
3932 assert (Config->get_solo_control_is_listen_control());
3934 if (route->solo_control()->soloed_by_self_or_masters()) {
3936 if (Config->get_exclusive_solo()) {
3938 RouteGroup* rg = route->route_group ();
3939 const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3941 boost::shared_ptr<RouteList> r = routes.reader ();
3943 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3944 if ((*i) == route) {
3945 /* already changed */
3949 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3950 /* route does not get solo propagated to it */
3954 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3955 /* this route is a part of the same solo group as the route
3956 * that was changed. Changing that route did change or will
3957 * change all group members appropriately, so we can ignore it
3962 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3968 } else if (_listen_cnt > 0) {
3975 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3977 boost::shared_ptr<Route> route (wpr.lock());
3983 bool send_changed = false;
3985 if (route->solo_isolate_control()->solo_isolated()) {
3986 if (_solo_isolated_cnt == 0) {
3987 send_changed = true;
3989 _solo_isolated_cnt++;
3990 } else if (_solo_isolated_cnt > 0) {
3991 _solo_isolated_cnt--;
3992 if (_solo_isolated_cnt == 0) {
3993 send_changed = true;
3998 IsolatedChanged (); /* EMIT SIGNAL */
4003 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
4005 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
4007 boost::shared_ptr<Route> route (wpr.lock());
4013 if (Config->get_solo_control_is_listen_control()) {
4014 route_listen_changed (group_override, wpr);
4018 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: self %2 masters %3 transition %4\n", route->name(), route->self_soloed(), route->solo_control()->get_masters_value(), route->solo_control()->transitioned_into_solo()));
4020 if (route->solo_control()->transitioned_into_solo() == 0) {
4021 /* route solo changed by upstream/downstream or clear all solo state; not interesting
4024 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 not self-soloed nor soloed by master (%2), ignoring\n", route->name(), route->solo_control()->get_masters_value()));
4028 boost::shared_ptr<RouteList> r = routes.reader ();
4029 int32_t delta = route->solo_control()->transitioned_into_solo ();
4031 /* the route may be a member of a group that has shared-solo
4032 * semantics. If so, then all members of that group should follow the
4033 * solo of the changed route. But ... this is optional, controlled by a
4034 * Controllable::GroupControlDisposition.
4036 * The first argument to the signal that this method is connected to is the
4037 * GroupControlDisposition value that was used to change solo.
4039 * If the solo change was done with group semantics (either InverseGroup
4040 * (force the entire group to change even if the group shared solo is
4041 * disabled) or UseGroup (use the group, which may or may not have the
4042 * shared solo property enabled)) then as we propagate the change to
4043 * the entire session we should IGNORE THE GROUP that the changed route
4047 RouteGroup* rg = route->route_group ();
4048 const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
4050 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
4052 if (delta == 1 && Config->get_exclusive_solo()) {
4054 /* new solo: disable all other solos, but not the group if its solo-enabled */
4056 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4058 if ((*i) == route) {
4059 /* already changed */
4063 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4064 /* route does not get solo propagated to it */
4068 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4069 /* this route is a part of the same solo group as the route
4070 * that was changed. Changing that route did change or will
4071 * change all group members appropriately, so we can ignore it
4077 (*i)->solo_control()->set_value (0.0, group_override);
4081 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
4083 RouteList uninvolved;
4085 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
4087 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4088 bool via_sends_only;
4089 bool in_signal_flow;
4091 if ((*i) == route) {
4092 /* already changed */
4096 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4097 /* route does not get solo propagated to it */
4098 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 excluded from solo because iso = %2 can_solo = %3\n", (*i)->name(), (*i)->solo_isolate_control()->solo_isolated(),
4103 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4104 /* this route is a part of the same solo group as the route
4105 * that was changed. Changing that route did change or will
4106 * change all group members appropriately, so we can ignore it
4112 in_signal_flow = false;
4114 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
4116 if ((*i)->feeds (route, &via_sends_only)) {
4117 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
4118 if (!via_sends_only) {
4119 if (!route->soloed_by_others_upstream()) {
4120 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
4122 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
4125 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
4127 in_signal_flow = true;
4129 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
4132 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
4134 if (route->feeds (*i, &via_sends_only)) {
4135 /* propagate solo upstream only if routing other than
4136 sends is involved, but do consider the other route
4137 (*i) to be part of the signal flow even if only
4140 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
4144 route->soloed_by_others_downstream(),
4145 route->soloed_by_others_upstream()));
4146 if (!via_sends_only) {
4147 //NB. Triggers Invert Push, which handles soloed by downstream
4148 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
4149 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
4151 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
4153 in_signal_flow = true;
4155 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
4158 if (!in_signal_flow) {
4159 uninvolved.push_back (*i);
4163 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
4165 /* now notify that the mute state of the routes not involved in the signal
4166 pathway of the just-solo-changed route may have altered.
4169 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
4170 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
4171 (*i)->act_on_mute ();
4172 /* Session will emit SoloChanged() after all solo changes are
4173 * complete, which should be used by UIs to update mute status
4179 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
4181 /* now figure out if anything that matters is soloed (or is "listening")*/
4183 bool something_soloed = false;
4184 bool something_listening = false;
4185 uint32_t listeners = 0;
4186 uint32_t isolated = 0;
4189 r = routes.reader();
4192 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4193 if ((*i)->can_solo()) {
4194 if (Config->get_solo_control_is_listen_control()) {
4195 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4197 something_listening = true;
4200 (*i)->set_listen (false);
4201 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4202 something_soloed = true;
4207 if ((*i)->solo_isolate_control()->solo_isolated()) {
4212 if (something_soloed != _non_soloed_outs_muted) {
4213 _non_soloed_outs_muted = something_soloed;
4214 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4217 if (something_listening != _listening) {
4218 _listening = something_listening;
4219 SoloActive (_listening);
4222 _listen_cnt = listeners;
4224 if (isolated != _solo_isolated_cnt) {
4225 _solo_isolated_cnt = isolated;
4226 IsolatedChanged (); /* EMIT SIGNAL */
4229 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4230 something_soloed, listeners, isolated));
4233 SoloChanged (); /* EMIT SIGNAL */
4238 Session::muted () const
4240 // TODO consider caching the value on every MuteChanged signal,
4241 // Note that API users may also subscribe to MuteChanged and hence
4242 // this method needs to be called first.
4245 get_stripables (all);
4246 for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4247 if ((*i)->is_auditioner() || (*i)->is_monitor()) {
4250 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route>(*i);
4251 if (r && !r->active()) {
4254 boost::shared_ptr<MuteControl> mc = (*i)->mute_control();
4255 if (mc && mc->muted ()) {
4263 std::vector<boost::weak_ptr<AutomationControl> >
4264 Session::cancel_all_mute ()
4267 get_stripables (all);
4268 std::vector<boost::weak_ptr<AutomationControl> > muted;
4269 boost::shared_ptr<ControlList> cl (new ControlList);
4270 for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4271 if ((*i)->is_auditioner() || (*i)->is_monitor()) {
4274 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (*i);
4275 if (r && !r->active()) {
4278 boost::shared_ptr<AutomationControl> ac = (*i)->mute_control();
4279 if (ac && ac->get_value () > 0) {
4281 muted.push_back (boost::weak_ptr<AutomationControl>(ac));
4284 if (!cl->empty ()) {
4285 set_controls (cl, 0.0, PBD::Controllable::UseGroup);
4291 Session::get_stripables (StripableList& sl) const
4293 boost::shared_ptr<RouteList> r = routes.reader ();
4294 sl.insert (sl.end(), r->begin(), r->end());
4296 VCAList v = _vca_manager->vcas ();
4297 sl.insert (sl.end(), v.begin(), v.end());
4301 Session::get_stripables () const
4304 Session::get_stripables (rv);
4305 rv.sort (Stripable::Sorter ());
4309 boost::shared_ptr<RouteList>
4310 Session::get_routes_with_internal_returns() const
4312 boost::shared_ptr<RouteList> r = routes.reader ();
4313 boost::shared_ptr<RouteList> rl (new RouteList);
4315 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4316 if ((*i)->internal_return ()) {
4324 Session::io_name_is_legal (const std::string& name) const
4326 boost::shared_ptr<RouteList> r = routes.reader ();
4328 for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4329 if (name == reserved->first) {
4330 if (!route_by_name (reserved->first)) {
4331 /* first instance of a reserved name is allowed for some */
4332 return reserved->second;
4334 /* all other instances of a reserved name are not allowed */
4339 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4340 if ((*i)->name() == name) {
4344 if ((*i)->has_io_processor_named (name)) {
4353 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4356 vector<string> connections;
4358 /* if we are passed only a single route and we're not told to turn
4359 * others off, then just do the simple thing.
4362 if (flip_others == false && rl->size() == 1) {
4363 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4365 mt->set_input_active (onoff);
4370 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4372 PortSet& ps ((*rt)->input()->ports());
4374 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4375 p->get_connections (connections);
4378 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4379 routes_using_input_from (*s, rl2);
4382 /* scan all relevant routes to see if others are on or off */
4384 bool others_are_already_on = false;
4386 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4388 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4394 if ((*r) != (*rt)) {
4395 if (mt->input_active()) {
4396 others_are_already_on = true;
4399 /* this one needs changing */
4400 mt->set_input_active (onoff);
4406 /* globally reverse other routes */
4408 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4409 if ((*r) != (*rt)) {
4410 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4412 mt->set_input_active (!others_are_already_on);
4421 Session::routes_using_input_from (const string& str, RouteList& rl)
4423 boost::shared_ptr<RouteList> r = routes.reader();
4425 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4426 if ((*i)->input()->connected_to (str)) {
4432 boost::shared_ptr<Route>
4433 Session::route_by_name (string name) const
4435 boost::shared_ptr<RouteList> r = routes.reader ();
4437 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4438 if ((*i)->name() == name) {
4443 return boost::shared_ptr<Route> ((Route*) 0);
4446 boost::shared_ptr<Route>
4447 Session::route_by_id (PBD::ID id) const
4449 boost::shared_ptr<RouteList> r = routes.reader ();
4451 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4452 if ((*i)->id() == id) {
4457 return boost::shared_ptr<Route> ((Route*) 0);
4461 boost::shared_ptr<Stripable>
4462 Session::stripable_by_id (PBD::ID id) const
4465 get_stripables (sl);
4467 for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4468 if ((*s)->id() == id) {
4473 return boost::shared_ptr<Stripable>();
4476 boost::shared_ptr<Processor>
4477 Session::processor_by_id (PBD::ID id) const
4479 boost::shared_ptr<RouteList> r = routes.reader ();
4481 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4482 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4488 return boost::shared_ptr<Processor> ();
4491 boost::shared_ptr<Track>
4492 Session::track_by_diskstream_id (PBD::ID id) const
4494 boost::shared_ptr<RouteList> r = routes.reader ();
4496 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4497 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4498 if (t && t->using_diskstream_id (id)) {
4503 return boost::shared_ptr<Track> ();
4506 boost::shared_ptr<Route>
4507 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4509 return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4512 boost::shared_ptr<Stripable>
4513 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4516 PresentationInfo::order_t match_cnt = 0;
4518 get_stripables (sl);
4519 sl.sort (Stripable::Sorter());
4521 for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4523 if ((*s)->presentation_info().hidden()) {
4524 /* if the caller didn't explicitly ask for hidden
4525 stripables, ignore hidden ones. This matches
4526 the semantics of the pre-PresentationOrder
4527 "get by RID" logic of Ardour 4.x and earlier.
4529 XXX at some point we should likely reverse
4530 the logic of the flags, because asking for "the
4531 hidden stripables" is not going to be common,
4532 whereas asking for visible ones is normal.
4535 if (! (flags & PresentationInfo::Hidden)) {
4540 if ((*s)->presentation_info().flag_match (flags)) {
4541 if (match_cnt++ == n) {
4547 /* there is no nth stripable that matches the given flags */
4548 return boost::shared_ptr<Stripable>();
4551 boost::shared_ptr<Route>
4552 Session::route_by_selected_count (uint32_t id) const
4554 RouteList r (*(routes.reader ()));
4555 r.sort (Stripable::Sorter());
4557 RouteList::iterator i;
4559 for (i = r.begin(); i != r.end(); ++i) {
4560 if ((*i)->is_selected()) {
4568 return boost::shared_ptr<Route> ();
4572 Session::reassign_track_numbers ()
4576 RouteList r (*(routes.reader ()));
4577 r.sort (Stripable::Sorter());
4579 StateProtector sp (this);
4581 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4582 if (boost::dynamic_pointer_cast<Track> (*i)) {
4583 (*i)->set_track_number(++tn);
4585 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4586 (*i)->set_track_number(--bn);
4589 const uint32_t decimals = ceilf (log10f (tn + 1));
4590 const bool decimals_changed = _track_number_decimals != decimals;
4591 _track_number_decimals = decimals;
4593 if (decimals_changed && config.get_track_name_number ()) {
4594 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4595 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4597 t->resync_track_name();
4600 // trigger GUI re-layout
4601 config.ParameterChanged("track-name-number");
4605 if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4606 boost::shared_ptr<RouteList> rl = routes.reader ();
4607 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4608 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4616 Session::playlist_region_added (boost::weak_ptr<Region> w)
4618 boost::shared_ptr<Region> r = w.lock ();
4623 /* These are the operations that are currently in progress... */
4624 list<GQuark> curr = _current_trans_quarks;
4627 /* ...and these are the operations during which we want to update
4628 the session range location markers.
4631 ops.push_back (Operations::capture);
4632 ops.push_back (Operations::paste);
4633 ops.push_back (Operations::duplicate_region);
4634 ops.push_back (Operations::insert_file);
4635 ops.push_back (Operations::insert_region);
4636 ops.push_back (Operations::drag_region_brush);
4637 ops.push_back (Operations::region_drag);
4638 ops.push_back (Operations::selection_grab);
4639 ops.push_back (Operations::region_fill);
4640 ops.push_back (Operations::fill_selection);
4641 ops.push_back (Operations::create_region);
4642 ops.push_back (Operations::region_copy);
4643 ops.push_back (Operations::fixed_time_region_copy);
4646 /* See if any of the current operations match the ones that we want */
4648 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4650 /* If so, update the session range markers */
4652 maybe_update_session_range (r->position (), r->last_frame ());
4656 /** Update the session range markers if a is before the current start or
4657 * b is after the current end.
4660 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4662 if (_state_of_the_state & Loading) {
4666 framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4668 if (_session_range_location == 0) {
4670 set_session_range_location (a, b + session_end_marker_shift_samples);
4674 if (a < _session_range_location->start()) {
4675 _session_range_location->set_start (a);
4678 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4679 _session_range_location->set_end (b);
4685 Session::set_end_is_free (bool yn)
4687 _session_range_end_is_free = yn;
4691 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4693 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4694 maybe_update_session_range (i->to, i->to + i->length);
4699 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4701 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4702 maybe_update_session_range (i->from, i->to);
4706 /* Region management */
4708 boost::shared_ptr<Region>
4709 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4711 const RegionFactory::RegionMap& regions (RegionFactory::regions());
4712 RegionFactory::RegionMap::const_iterator i;
4713 boost::shared_ptr<Region> region;
4715 Glib::Threads::Mutex::Lock lm (region_lock);
4717 for (i = regions.begin(); i != regions.end(); ++i) {
4721 if (region->whole_file()) {
4723 if (child->source_equivalent (region)) {
4729 return boost::shared_ptr<Region> ();
4733 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4735 set<boost::shared_ptr<Region> > relevant_regions;
4737 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4738 RegionFactory::get_regions_using_source (*s, relevant_regions);
4741 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4742 set<boost::shared_ptr<Region> >::iterator tmp;
4747 playlists->destroy_region (*r);
4748 RegionFactory::map_remove (*r);
4750 (*r)->drop_sources ();
4751 (*r)->drop_references ();
4753 relevant_regions.erase (r);
4758 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4761 Glib::Threads::Mutex::Lock ls (source_lock);
4762 /* remove from the main source list */
4763 sources.erase ((*s)->id());
4766 (*s)->mark_for_remove ();
4767 (*s)->drop_references ();
4776 Session::remove_last_capture ()
4778 list<boost::shared_ptr<Source> > srcs;
4780 boost::shared_ptr<RouteList> rl = routes.reader ();
4781 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4782 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4787 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4790 srcs.insert (srcs.end(), l.begin(), l.end());
4795 destroy_sources (srcs);
4797 save_state (_current_snapshot_name);
4802 /* Source Management */
4805 Session::add_source (boost::shared_ptr<Source> source)
4807 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4808 pair<SourceMap::iterator,bool> result;
4810 entry.first = source->id();
4811 entry.second = source;
4814 Glib::Threads::Mutex::Lock lm (source_lock);
4815 result = sources.insert (entry);
4818 if (result.second) {
4820 /* yay, new source */
4822 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4825 if (!fs->within_session()) {
4826 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4832 boost::shared_ptr<AudioFileSource> afs;
4834 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4835 if (Config->get_auto_analyse_audio()) {
4836 Analyser::queue_source_for_analysis (source, false);
4840 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4845 Session::remove_source (boost::weak_ptr<Source> src)
4847 if (_state_of_the_state & Deletion) {
4851 SourceMap::iterator i;
4852 boost::shared_ptr<Source> source = src.lock();
4859 Glib::Threads::Mutex::Lock lm (source_lock);
4861 if ((i = sources.find (source->id())) != sources.end()) {
4866 if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4868 /* save state so we don't end up with a session file
4869 referring to non-existent sources.
4872 save_state (_current_snapshot_name);
4876 boost::shared_ptr<Source>
4877 Session::source_by_id (const PBD::ID& id)
4879 Glib::Threads::Mutex::Lock lm (source_lock);
4880 SourceMap::iterator i;
4881 boost::shared_ptr<Source> source;
4883 if ((i = sources.find (id)) != sources.end()) {
4890 boost::shared_ptr<AudioFileSource>
4891 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4893 /* Restricted to audio files because only audio sources have channel
4897 Glib::Threads::Mutex::Lock lm (source_lock);
4899 for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4900 boost::shared_ptr<AudioFileSource> afs
4901 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4903 if (afs && afs->path() == path && chn == afs->channel()) {
4908 return boost::shared_ptr<AudioFileSource>();
4911 boost::shared_ptr<MidiSource>
4912 Session::midi_source_by_path (const std::string& path, bool need_source_lock) const
4914 /* Restricted to MIDI files because audio sources require a channel
4915 for unique identification, in addition to a path.
4918 Glib::Threads::Mutex::Lock lm (source_lock, Glib::Threads::NOT_LOCK);
4919 if (need_source_lock) {
4923 for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4924 boost::shared_ptr<MidiSource> ms
4925 = boost::dynamic_pointer_cast<MidiSource>(s->second);
4926 boost::shared_ptr<FileSource> fs
4927 = boost::dynamic_pointer_cast<FileSource>(s->second);
4929 if (ms && fs && fs->path() == path) {
4934 return boost::shared_ptr<MidiSource>();
4938 Session::count_sources_by_origin (const string& path)
4941 Glib::Threads::Mutex::Lock lm (source_lock);
4943 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4944 boost::shared_ptr<FileSource> fs
4945 = boost::dynamic_pointer_cast<FileSource>(i->second);
4947 if (fs && fs->origin() == path) {
4956 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4958 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4959 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4961 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4966 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4968 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4970 if (Glib::path_is_absolute (filepath)) {
4972 /* rip the session dir from the audiofile source */
4974 string session_path;
4975 bool in_another_session = true;
4977 if (filepath.find (interchange_dir_string) != string::npos) {
4979 session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4980 session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4981 session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4982 session_path = Glib::path_get_dirname (session_path); /* now has session path */
4984 /* see if it is within our session */
4986 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4987 if (i->path == session_path) {
4988 in_another_session = false;
4993 in_another_session = false;
4997 if (in_another_session) {
4998 SessionDirectory sd (session_path);
4999 return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
5003 /* 1) if file belongs to this session
5004 * it may be a relative path (interchange/...)
5005 * or just basename (session_state, remove source)
5006 * -> just use the basename
5008 std::string filename = Glib::path_get_basename (filepath);
5011 /* 2) if the file is outside our session dir:
5012 * (imported but not copied) add the path for check-summming */
5014 path = Glib::path_get_dirname (filepath);
5017 return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
5021 Session::new_audio_source_path_for_embedded (const std::string& path)
5025 * we know that the filename is already unique because it exists
5026 * out in the filesystem.
5028 * However, when we bring it into the session, we could get a
5031 * Eg. two embedded files:
5036 * When merged into session, these collide.
5038 * There will not be a conflict with in-memory sources
5039 * because when the source was created we already picked
5040 * a unique name for it.
5042 * This collision is not likely to be common, but we have to guard
5043 * against it. So, if there is a collision, take the md5 hash of the
5044 * the path, and use that as the filename instead.
5047 SessionDirectory sdir (get_best_session_directory_for_new_audio());
5048 string base = Glib::path_get_basename (path);
5049 string newpath = Glib::build_filename (sdir.sound_path(), base);
5051 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5055 md5.digestString (path.c_str());
5056 md5.writeToString ();
5057 base = md5.digestChars;
5059 string ext = get_suffix (path);
5066 newpath = Glib::build_filename (sdir.sound_path(), base);
5068 /* if this collides, we're screwed */
5070 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5071 error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
5080 /** Return true if there are no audio file sources that use @param name as
5081 * the filename component of their path.
5083 * Return false otherwise.
5085 * This method MUST ONLY be used to check in-session, mono files since it
5086 * hard-codes the channel of the audio file source we are looking for as zero.
5088 * If/when Ardour supports native files in non-mono formats, the logic here
5089 * will need to be revisited.
5092 Session::audio_source_name_is_unique (const string& name)
5094 std::vector<string> sdirs = source_search_path (DataType::AUDIO);
5095 vector<space_and_path>::iterator i;
5096 uint32_t existing = 0;
5098 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5100 /* note that we search *without* the extension so that
5101 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
5102 in the event that this new name is required for
5103 a file format change.
5106 const string spath = *i;
5108 if (matching_unsuffixed_filename_exists_in (spath, name)) {
5113 /* it is possible that we have the path already
5114 * assigned to a source that has not yet been written
5115 * (ie. the write source for a diskstream). we have to
5116 * check this in order to make sure that our candidate
5117 * path isn't used again, because that can lead to
5118 * two Sources point to the same file with different
5119 * notions of their removability.
5123 string possible_path = Glib::build_filename (spath, name);
5125 if (audio_source_by_path_and_channel (possible_path, 0)) {
5131 return (existing == 0);
5135 Session::format_audio_source_name (const string& legalized_base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required, uint32_t cnt, bool related_exists)
5138 const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5140 if (Profile->get_trx() && destructive) {
5142 sstr << setfill ('0') << setw (4) << cnt;
5143 sstr << legalized_base;
5145 sstr << legalized_base;
5147 if (take_required || related_exists) {
5159 } else if (nchan > 2) {
5164 /* XXX what? more than 26 channels! */
5175 /** Return a unique name based on \a base for a new internal audio source */
5177 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5180 string possible_name;
5181 const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5183 bool some_related_source_name_exists = false;
5185 legalized = legalize_for_path (base);
5187 // Find a "version" of the base name that doesn't exist in any of the possible directories.
5189 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5191 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5193 if (audio_source_name_is_unique (possible_name)) {
5197 some_related_source_name_exists = true;
5200 error << string_compose(
5201 _("There are already %1 recordings for %2, which I consider too many."),
5202 limit, base) << endmsg;
5204 throw failed_constructor();
5208 /* We've established that the new name does not exist in any session
5209 * directory, so now find out which one we should use for this new
5213 SessionDirectory sdir (get_best_session_directory_for_new_audio());
5215 std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5220 /** Return a unique name based on `base` for a new internal MIDI source */
5222 Session::new_midi_source_path (const string& base, bool need_lock)
5225 char buf[PATH_MAX+1];
5226 const uint32_t limit = 10000;
5228 string possible_path;
5229 string possible_name;
5232 legalized = legalize_for_path (base);
5234 // Find a "version" of the file name that doesn't exist in any of the possible directories.
5235 std::vector<string> sdirs = source_search_path(DataType::MIDI);
5237 /* - the main session folder is the first in the vector.
5238 * - after checking all locations for file-name uniqueness,
5239 * we keep the one from the last iteration as new file name
5240 * - midi files are small and should just be kept in the main session-folder
5242 * -> reverse the array, check main session folder last and use that as location
5245 std::reverse(sdirs.begin(), sdirs.end());
5247 for (cnt = 1; cnt <= limit; ++cnt) {
5249 vector<space_and_path>::iterator i;
5250 uint32_t existing = 0;
5252 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5254 snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
5255 possible_name = buf;
5257 possible_path = Glib::build_filename (*i, possible_name);
5259 if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5263 if (midi_source_by_path (possible_path, need_lock)) {
5268 if (existing == 0) {
5273 error << string_compose(
5274 _("There are already %1 recordings for %2, which I consider too many."),
5275 limit, base) << endmsg;
5281 /* No need to "find best location" for software/app-based RAID, because
5282 MIDI is so small that we always put it in the same place.
5285 return possible_path;
5289 /** Create a new within-session audio source */
5290 boost::shared_ptr<AudioFileSource>
5291 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5293 const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5295 if (!path.empty()) {
5296 return boost::dynamic_pointer_cast<AudioFileSource> (
5297 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
5299 throw failed_constructor ();
5303 /** Create a new within-session MIDI source */
5304 boost::shared_ptr<MidiSource>
5305 Session::create_midi_source_for_session (string const & basic_name)
5307 const string path = new_midi_source_path (basic_name);
5309 if (!path.empty()) {
5310 return boost::dynamic_pointer_cast<SMFSource> (
5311 SourceFactory::createWritable (
5312 DataType::MIDI, *this, path, false, frame_rate()));
5314 throw failed_constructor ();
5318 /** Create a new within-session MIDI source */
5319 boost::shared_ptr<MidiSource>
5320 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5322 /* the caller passes in the track the source will be used in,
5323 so that we can keep the numbering sane.
5325 Rationale: a track with the name "Foo" that has had N
5326 captures carried out so far will ALREADY have a write source
5327 named "Foo-N+1.mid" waiting to be used for the next capture.
5329 If we call new_midi_source_name() we will get "Foo-N+2". But
5330 there is no region corresponding to "Foo-N+1", so when
5331 "Foo-N+2" appears in the track, the gap presents the user
5332 with odd behaviour - why did it skip past Foo-N+1?
5334 We could explain this to the user in some odd way, but
5335 instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5338 If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5341 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5343 std::string name = track->steal_write_source_name ();
5346 return boost::shared_ptr<MidiSource>();
5349 /* MIDI files are small, just put them in the first location of the
5350 session source search path.
5353 const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5355 return boost::dynamic_pointer_cast<SMFSource> (
5356 SourceFactory::createWritable (
5357 DataType::MIDI, *this, path, false, frame_rate()));
5362 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5364 if (playlist->hidden()) {
5368 playlists->add (playlist);
5371 playlist->release();
5378 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5380 if (_state_of_the_state & Deletion) {
5384 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5390 playlists->remove (playlist);
5396 Session::set_audition (boost::shared_ptr<Region> r)
5398 pending_audition_region = r;
5399 add_post_transport_work (PostTransportAudition);
5400 _butler->schedule_transport_work ();
5404 Session::audition_playlist ()
5406 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5407 ev->region.reset ();
5413 Session::register_lua_function (
5414 const std::string& name,
5415 const std::string& script,
5416 const LuaScriptParamList& args
5419 Glib::Threads::Mutex::Lock lm (lua_lock);
5421 lua_State* L = lua.getState();
5423 const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5424 luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5425 for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5426 if ((*i)->optional && !(*i)->is_set) { continue; }
5427 tbl_arg[(*i)->name] = (*i)->value;
5429 (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5432 LuaScriptsChanged (); /* EMIT SIGNAL */
5437 Session::unregister_lua_function (const std::string& name)
5439 Glib::Threads::Mutex::Lock lm (lua_lock);
5440 (*_lua_del)(name); // throws luabridge::LuaException
5441 lua.collect_garbage ();
5444 LuaScriptsChanged (); /* EMIT SIGNAL */
5448 std::vector<std::string>
5449 Session::registered_lua_functions ()
5451 Glib::Threads::Mutex::Lock lm (lua_lock);
5452 std::vector<std::string> rv;
5455 luabridge::LuaRef list ((*_lua_list)());
5456 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5457 if (!i.key ().isString ()) { assert(0); continue; }
5458 rv.push_back (i.key ().cast<std::string> ());
5460 } catch (luabridge::LuaException const& e) { }
5465 static void _lua_print (std::string s) {
5466 std::cout << "SessionLua: " << s << "\n";
5471 Session::try_run_lua (pframes_t nframes)
5473 if (_n_lua_scripts == 0) return;
5474 Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5476 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5477 lua.collect_garbage_step ();
5482 Session::setup_lua ()
5485 lua.Print.connect (&_lua_print);
5489 "function ArdourSession ()"
5490 " local self = { scripts = {}, instances = {} }"
5492 " local remove = function (n)"
5493 " self.scripts[n] = nil"
5494 " self.instances[n] = nil"
5495 " Session:scripts_changed()" // call back
5498 " local addinternal = function (n, f, a)"
5499 " assert(type(n) == 'string', 'function-name must be string')"
5500 " assert(type(f) == 'function', 'Given script is a not a function')"
5501 " assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5502 " assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5503 " self.scripts[n] = { ['f'] = f, ['a'] = a }"
5504 " local env = _ENV; env.f = nil env.io = nil env.os = nil env.loadfile = nil env.require = nil env.dofile = nil env.package = nil env.debug = nil"
5505 " local env = { print = print, tostring = tostring, assert = assert, ipairs = ipairs, error = error, select = select, string = string, type = type, tonumber = tonumber, collectgarbage = collectgarbage, pairs = pairs, math = math, table = table, pcall = pcall, bit32=bit32, Session = Session, PBD = PBD, Timecode = Timecode, Evoral = Evoral, C = C, ARDOUR = ARDOUR }"
5506 " self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5507 " Session:scripts_changed()" // call back
5510 " local add = function (n, b, a)"
5511 " assert(type(b) == 'string', 'ByteCode must be string')"
5512 " load (b)()" // assigns f
5513 " assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5514 " addinternal (n, load(f), a)"
5517 " local run = function (...)"
5518 " for n, s in pairs (self.instances) do"
5519 " local status, err = pcall (s, ...)"
5520 " if not status then"
5521 " print ('fn \"'.. n .. '\": ', err)"
5528 " local cleanup = function ()"
5529 " self.scripts = nil"
5530 " self.instances = nil"
5533 " local list = function ()"
5535 " for n, _ in pairs (self.scripts) do"
5541 " local function basic_serialize (o)"
5542 " if type(o) == \"number\" then"
5543 " return tostring(o)"
5545 " return string.format(\"%q\", o)"
5549 " local function serialize (name, value)"
5550 " local rv = name .. ' = '"
5552 " if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5553 " return rv .. basic_serialize(value) .. ' '"
5554 " elseif type(value) == \"table\" then"
5556 " for k,v in pairs(value) do"
5557 " local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5558 " rv = rv .. serialize(fieldname, v) .. ' '"
5559 " collectgarbage()" // string concatenation allocates a new string :(
5562 " elseif type(value) == \"function\" then"
5563 " return rv .. string.format(\"%q\", string.dump(value, true))"
5565 " error('cannot save a ' .. type(value))"
5570 " local save = function ()"
5571 " return (serialize('scripts', self.scripts))"
5574 " local restore = function (state)"
5575 " self.scripts = {}"
5577 " for n, s in pairs (scripts) do"
5578 " addinternal (n, load(s['f']), s['a'])"
5582 " return { run = run, add = add, remove = remove,"
5583 " list = list, restore = restore, save = save, cleanup = cleanup}"
5586 " sess = ArdourSession ()"
5587 " ArdourSession = nil"
5589 "function ardour () end"
5592 lua_State* L = lua.getState();
5595 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5596 lua.do_command ("sess = nil"); // hide it.
5597 lua.do_command ("collectgarbage()");
5599 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5600 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5601 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5602 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5603 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5604 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5605 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5606 } catch (luabridge::LuaException const& e) {
5607 fatal << string_compose (_("programming error: %1"),
5608 X_("Failed to setup Lua interpreter"))
5610 abort(); /*NOTREACHED*/
5613 LuaBindings::stddef (L);
5614 LuaBindings::common (L);
5615 LuaBindings::dsp (L);
5616 luabridge::push <Session *> (L, this);
5617 lua_setglobal (L, "Session");
5621 Session::scripts_changed ()
5623 assert (!lua_lock.trylock()); // must hold lua_lock
5626 luabridge::LuaRef list ((*_lua_list)());
5628 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5629 if (!i.key ().isString ()) { assert(0); continue; }
5632 _n_lua_scripts = cnt;
5633 } catch (luabridge::LuaException const& e) {
5634 fatal << string_compose (_("programming error: %1"),
5635 X_("Indexing Lua Session Scripts failed."))
5637 abort(); /*NOTREACHED*/
5642 Session::non_realtime_set_audition ()
5644 assert (pending_audition_region);
5645 auditioner->audition_region (pending_audition_region);
5646 pending_audition_region.reset ();
5647 AuditionActive (true); /* EMIT SIGNAL */
5651 Session::audition_region (boost::shared_ptr<Region> r)
5653 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5659 Session::cancel_audition ()
5664 if (auditioner->auditioning()) {
5665 auditioner->cancel_audition ();
5666 AuditionActive (false); /* EMIT SIGNAL */
5671 Session::is_auditioning () const
5673 /* can be called before we have an auditioner object */
5675 return auditioner->auditioning();
5682 Session::graph_reordered ()
5684 /* don't do this stuff if we are setting up connections
5685 from a set_state() call or creating new tracks. Ditto for deletion.
5688 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5692 /* every track/bus asked for this to be handled but it was deferred because
5693 we were connecting. do it now.
5696 request_input_change_handling ();
5700 /* force all diskstreams to update their capture offset values to
5701 reflect any changes in latencies within the graph.
5704 boost::shared_ptr<RouteList> rl = routes.reader ();
5705 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5706 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5708 tr->set_capture_offset ();
5713 /** @return Number of frames that there is disk space available to write,
5716 boost::optional<framecnt_t>
5717 Session::available_capture_duration ()
5719 Glib::Threads::Mutex::Lock lm (space_lock);
5721 if (_total_free_4k_blocks_uncertain) {
5722 return boost::optional<framecnt_t> ();
5725 float sample_bytes_on_disk = 4.0; // keep gcc happy
5727 switch (config.get_native_file_data_format()) {
5729 sample_bytes_on_disk = 4.0;
5733 sample_bytes_on_disk = 3.0;
5737 sample_bytes_on_disk = 2.0;
5741 /* impossible, but keep some gcc versions happy */
5742 fatal << string_compose (_("programming error: %1"),
5743 X_("illegal native file data format"))
5745 abort(); /*NOTREACHED*/
5748 double scale = 4096.0 / sample_bytes_on_disk;
5750 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5751 return max_framecnt;
5754 return (framecnt_t) floor (_total_free_4k_blocks * scale);
5758 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5761 RCUWriter<BundleList> writer (_bundles);
5762 boost::shared_ptr<BundleList> b = writer.get_copy ();
5763 b->push_back (bundle);
5767 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5774 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5776 bool removed = false;
5779 RCUWriter<BundleList> writer (_bundles);
5780 boost::shared_ptr<BundleList> b = writer.get_copy ();
5781 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5783 if (i != b->end()) {
5790 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5796 boost::shared_ptr<Bundle>
5797 Session::bundle_by_name (string name) const
5799 boost::shared_ptr<BundleList> b = _bundles.reader ();
5801 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5802 if ((*i)->name() == name) {
5807 return boost::shared_ptr<Bundle> ();
5811 Session::tempo_map_changed (const PropertyChange&)
5815 playlists->update_after_tempo_map_change ();
5817 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5823 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5825 for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5826 (*i)->recompute_frames_from_beat ();
5830 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5831 * the given count with the current block size.
5834 Session::ensure_buffers (ChanCount howmany)
5836 BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5840 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5842 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5843 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5848 Session::next_insert_id ()
5850 /* this doesn't really loop forever. just think about it */
5853 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5854 if (!insert_bitset[n]) {
5855 insert_bitset[n] = true;
5861 /* none available, so resize and try again */
5863 insert_bitset.resize (insert_bitset.size() + 16, false);
5868 Session::next_send_id ()
5870 /* this doesn't really loop forever. just think about it */
5873 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5874 if (!send_bitset[n]) {
5875 send_bitset[n] = true;
5881 /* none available, so resize and try again */
5883 send_bitset.resize (send_bitset.size() + 16, false);
5888 Session::next_aux_send_id ()
5890 /* this doesn't really loop forever. just think about it */
5893 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5894 if (!aux_send_bitset[n]) {
5895 aux_send_bitset[n] = true;
5901 /* none available, so resize and try again */
5903 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5908 Session::next_return_id ()
5910 /* this doesn't really loop forever. just think about it */
5913 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5914 if (!return_bitset[n]) {
5915 return_bitset[n] = true;
5921 /* none available, so resize and try again */
5923 return_bitset.resize (return_bitset.size() + 16, false);
5928 Session::mark_send_id (uint32_t id)
5930 if (id >= send_bitset.size()) {
5931 send_bitset.resize (id+16, false);
5933 if (send_bitset[id]) {
5934 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5936 send_bitset[id] = true;
5940 Session::mark_aux_send_id (uint32_t id)
5942 if (id >= aux_send_bitset.size()) {
5943 aux_send_bitset.resize (id+16, false);
5945 if (aux_send_bitset[id]) {
5946 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5948 aux_send_bitset[id] = true;
5952 Session::mark_return_id (uint32_t id)
5954 if (id >= return_bitset.size()) {
5955 return_bitset.resize (id+16, false);
5957 if (return_bitset[id]) {
5958 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5960 return_bitset[id] = true;
5964 Session::mark_insert_id (uint32_t id)
5966 if (id >= insert_bitset.size()) {
5967 insert_bitset.resize (id+16, false);
5969 if (insert_bitset[id]) {
5970 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5972 insert_bitset[id] = true;
5976 Session::unmark_send_id (uint32_t id)
5978 if (id < send_bitset.size()) {
5979 send_bitset[id] = false;
5984 Session::unmark_aux_send_id (uint32_t id)
5986 if (id < aux_send_bitset.size()) {
5987 aux_send_bitset[id] = false;
5992 Session::unmark_return_id (uint32_t id)
5994 if (_state_of_the_state & Deletion) { return; }
5995 if (id < return_bitset.size()) {
5996 return_bitset[id] = false;
6001 Session::unmark_insert_id (uint32_t id)
6003 if (id < insert_bitset.size()) {
6004 insert_bitset[id] = false;
6009 Session::reset_native_file_format ()
6011 boost::shared_ptr<RouteList> rl = routes.reader ();
6013 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6014 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6016 /* don't save state as we do this, there's no point
6018 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
6019 tr->reset_write_sources (false);
6020 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
6026 Session::route_name_unique (string n) const
6028 boost::shared_ptr<RouteList> r = routes.reader ();
6030 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6031 if ((*i)->name() == n) {
6040 Session::route_name_internal (string n) const
6042 if (auditioner && auditioner->name() == n) {
6046 if (_click_io && _click_io->name() == n) {
6054 Session::freeze_all (InterThreadInfo& itt)
6056 boost::shared_ptr<RouteList> r = routes.reader ();
6058 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6060 boost::shared_ptr<Track> t;
6062 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
6063 /* XXX this is wrong because itt.progress will keep returning to zero at the start
6073 boost::shared_ptr<Region>
6074 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
6075 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
6076 InterThreadInfo& itt,
6077 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
6078 bool for_export, bool for_freeze)
6080 boost::shared_ptr<Region> result;
6081 boost::shared_ptr<Playlist> playlist;
6082 boost::shared_ptr<Source> source;
6083 ChanCount diskstream_channels (track.n_channels());
6084 framepos_t position;
6085 framecnt_t this_chunk;
6087 framepos_t latency_skip;
6089 framepos_t len = end - start;
6090 bool need_block_size_reset = false;
6091 ChanCount const max_proc = track.max_processor_streams ();
6092 string legal_playlist_name;
6093 string possible_path;
6096 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
6097 end, start) << endmsg;
6101 diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
6102 include_endpoint, for_export, for_freeze);
6104 if (diskstream_channels.n(track.data_type()) < 1) {
6105 error << _("Cannot write a range with no data.") << endmsg;
6109 // block all process callback handling
6111 block_processing ();
6114 // synchronize with AudioEngine::process_callback()
6115 // make sure processing is not currently running
6116 // and processing_blocked() is honored before
6117 // acquiring thread buffers
6118 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6121 _bounce_processing_active = true;
6123 /* call tree *MUST* hold route_lock */
6125 if ((playlist = track.playlist()) == 0) {
6129 legal_playlist_name = legalize_for_path (playlist->name());
6131 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
6133 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
6134 string path = ((track.data_type() == DataType::AUDIO)
6135 ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
6136 : new_midi_source_path (legal_playlist_name));
6143 source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
6146 catch (failed_constructor& err) {
6147 error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
6151 srcs.push_back (source);
6154 /* tell redirects that care that we are about to use a much larger
6155 * blocksize. this will flush all plugins too, so that they are ready
6156 * to be used for this process.
6159 need_block_size_reset = true;
6160 track.set_block_size (bounce_chunk_size);
6161 _engine.main_thread()->get_buffers ();
6165 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6167 /* create a set of reasonably-sized buffers */
6168 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6169 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
6171 buffers.set_count (max_proc);
6173 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6174 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6175 boost::shared_ptr<MidiSource> ms;
6177 afs->prepare_for_peakfile_writes ();
6178 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6179 Source::Lock lock(ms->mutex());
6180 ms->mark_streaming_write_started(lock);
6184 while (to_do && !itt.cancel) {
6186 this_chunk = min (to_do, bounce_chunk_size);
6188 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
6192 start += this_chunk;
6193 to_do -= this_chunk;
6194 itt.progress = (float) (1.0 - ((double) to_do / len));
6196 if (latency_skip >= bounce_chunk_size) {
6197 latency_skip -= bounce_chunk_size;
6201 const framecnt_t current_chunk = this_chunk - latency_skip;
6204 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6205 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6206 boost::shared_ptr<MidiSource> ms;
6209 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
6212 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6213 Source::Lock lock(ms->mutex());
6215 const MidiBuffer& buf = buffers.get_midi(0);
6216 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
6217 Evoral::Event<framepos_t> ev = *i;
6218 ev.set_time(ev.time() - position);
6219 ms->append_event_frames(lock, ev, ms->timeline_position());
6226 /* post-roll, pick up delayed processor output */
6227 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6229 while (latency_skip && !itt.cancel) {
6230 this_chunk = min (latency_skip, bounce_chunk_size);
6231 latency_skip -= this_chunk;
6233 buffers.silence (this_chunk, 0);
6234 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
6237 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6238 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6241 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
6253 xnow = localtime (&now);
6255 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6256 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6257 boost::shared_ptr<MidiSource> ms;
6260 afs->update_header (position, *xnow, now);
6261 afs->flush_header ();
6262 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6263 Source::Lock lock(ms->mutex());
6264 ms->mark_streaming_write_completed(lock);
6268 /* construct a region to represent the bounced material */
6272 plist.add (Properties::start, 0);
6273 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6274 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6276 result = RegionFactory::create (srcs, plist);
6282 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6283 (*src)->mark_for_remove ();
6284 (*src)->drop_references ();
6288 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6289 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6292 afs->done_with_peakfile_writes ();
6296 _bounce_processing_active = false;
6298 if (need_block_size_reset) {
6299 _engine.main_thread()->drop_buffers ();
6300 track.set_block_size (get_block_size());
6303 unblock_processing ();
6309 Session::gain_automation_buffer() const
6311 return ProcessThread::gain_automation_buffer ();
6315 Session::trim_automation_buffer() const
6317 return ProcessThread::trim_automation_buffer ();
6321 Session::send_gain_automation_buffer() const
6323 return ProcessThread::send_gain_automation_buffer ();
6327 Session::scratch_automation_buffer() const
6329 return ProcessThread::scratch_automation_buffer ();
6333 Session::pan_automation_buffer() const
6335 return ProcessThread::pan_automation_buffer ();
6339 Session::get_silent_buffers (ChanCount count)
6341 return ProcessThread::get_silent_buffers (count);
6345 Session::get_scratch_buffers (ChanCount count, bool silence)
6347 return ProcessThread::get_scratch_buffers (count, silence);
6351 Session::get_noinplace_buffers (ChanCount count)
6353 return ProcessThread::get_noinplace_buffers (count);
6357 Session::get_route_buffers (ChanCount count, bool silence)
6359 return ProcessThread::get_route_buffers (count, silence);
6364 Session::get_mix_buffers (ChanCount count)
6366 return ProcessThread::get_mix_buffers (count);
6370 Session::ntracks () const
6373 boost::shared_ptr<RouteList> r = routes.reader ();
6375 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6376 if (boost::dynamic_pointer_cast<Track> (*i)) {
6385 Session::nbusses () const
6388 boost::shared_ptr<RouteList> r = routes.reader ();
6390 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6391 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6400 Session::nstripables (bool with_auditioner_and_monitor) const
6402 uint32_t rv = routes.reader()->size ();
6403 rv += _vca_manager->vcas ().size ();
6405 if (with_auditioner_and_monitor) {
6421 Session::add_automation_list(AutomationList *al)
6423 automation_lists[al->id()] = al;
6426 /** @return true if there is at least one record-enabled track, otherwise false */
6428 Session::have_rec_enabled_track () const
6430 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6434 Session::have_rec_disabled_track () const
6436 return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6439 /** Update the state of our rec-enabled tracks flag */
6441 Session::update_route_record_state ()
6443 boost::shared_ptr<RouteList> rl = routes.reader ();
6444 RouteList::iterator i = rl->begin();
6445 while (i != rl->end ()) {
6447 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6448 if (tr && tr->rec_enable_control()->get_value()) {
6455 int const old = g_atomic_int_get (&_have_rec_enabled_track);
6457 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6459 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6460 RecordStateChanged (); /* EMIT SIGNAL */
6463 for (i = rl->begin(); i != rl->end (); ++i) {
6464 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6465 if (tr && !tr->rec_enable_control()->get_value()) {
6470 g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6472 bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6474 if (record_status() == Recording && record_arm_state_changed ) {
6475 RecordArmStateChanged ();
6481 Session::listen_position_changed ()
6483 ProcessorChangeBlocker pcb (this);
6484 boost::shared_ptr<RouteList> r = routes.reader ();
6485 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6486 (*i)->listen_position_changed ();
6491 Session::solo_control_mode_changed ()
6493 if (soloing() || listening()) {
6495 /* We can't use ::clear_all_solo_state() here because during
6496 session loading at program startup, that will queue a call
6497 to rt_clear_all_solo_state() that will not execute until
6498 AFTER solo states have been established (thus throwing away
6499 the session's saved solo state). So just explicitly turn
6502 set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6504 clear_all_solo_state (get_routes());
6509 /** Called when a property of one of our route groups changes */
6511 Session::route_group_property_changed (RouteGroup* rg)
6513 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6516 /** Called when a route is added to one of our route groups */
6518 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6520 RouteAddedToRouteGroup (rg, r);
6523 /** Called when a route is removed from one of our route groups */
6525 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6527 update_route_record_state ();
6528 RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6530 if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6531 remove_route_group (*rg);
6535 boost::shared_ptr<RouteList>
6536 Session::get_tracks () const
6538 boost::shared_ptr<RouteList> rl = routes.reader ();
6539 boost::shared_ptr<RouteList> tl (new RouteList);
6541 for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6542 if (boost::dynamic_pointer_cast<Track> (*r)) {
6543 if (!(*r)->is_auditioner()) {
6551 boost::shared_ptr<RouteList>
6552 Session::get_routes_with_regions_at (framepos_t const p) const
6554 boost::shared_ptr<RouteList> r = routes.reader ();
6555 boost::shared_ptr<RouteList> rl (new RouteList);
6557 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6558 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6563 boost::shared_ptr<Playlist> pl = tr->playlist ();
6568 if (pl->has_region_at (p)) {
6577 Session::goto_end ()
6579 if (_session_range_location) {
6580 request_locate (_session_range_location->end(), false);
6582 request_locate (0, false);
6587 Session::goto_start (bool and_roll)
6589 if (_session_range_location) {
6590 request_locate (_session_range_location->start(), and_roll);
6592 request_locate (0, and_roll);
6597 Session::current_start_frame () const
6599 return _session_range_location ? _session_range_location->start() : 0;
6603 Session::current_end_frame () const
6605 return _session_range_location ? _session_range_location->end() : 0;
6609 Session::set_session_range_location (framepos_t start, framepos_t end)
6611 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange, 0);
6612 _locations->add (_session_range_location);
6616 Session::step_edit_status_change (bool yn)
6622 send = (_step_editors == 0);
6627 send = (_step_editors == 1);
6630 if (_step_editors > 0) {
6636 StepEditStatusChange (val);
6642 Session::start_time_changed (framepos_t old)
6644 /* Update the auto loop range to match the session range
6645 (unless the auto loop range has been changed by the user)
6648 Location* s = _locations->session_range_location ();
6653 Location* l = _locations->auto_loop_location ();
6655 if (l && l->start() == old) {
6656 l->set_start (s->start(), true);
6662 Session::end_time_changed (framepos_t old)
6664 /* Update the auto loop range to match the session range
6665 (unless the auto loop range has been changed by the user)
6668 Location* s = _locations->session_range_location ();
6673 Location* l = _locations->auto_loop_location ();
6675 if (l && l->end() == old) {
6676 l->set_end (s->end(), true);
6681 std::vector<std::string>
6682 Session::source_search_path (DataType type) const
6686 if (session_dirs.size() == 1) {
6688 case DataType::AUDIO:
6689 sp.push_back (_session_dir->sound_path());
6691 case DataType::MIDI:
6692 sp.push_back (_session_dir->midi_path());
6696 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6697 SessionDirectory sdir (i->path);
6699 case DataType::AUDIO:
6700 sp.push_back (sdir.sound_path());
6702 case DataType::MIDI:
6703 sp.push_back (sdir.midi_path());
6709 if (type == DataType::AUDIO) {
6710 const string sound_path_2X = _session_dir->sound_path_2X();
6711 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6712 if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6713 sp.push_back (sound_path_2X);
6718 // now check the explicit (possibly user-specified) search path
6721 case DataType::AUDIO:
6722 sp += Searchpath(config.get_audio_search_path ());
6724 case DataType::MIDI:
6725 sp += Searchpath(config.get_midi_search_path ());
6733 Session::ensure_search_path_includes (const string& path, DataType type)
6742 case DataType::AUDIO:
6743 sp += Searchpath(config.get_audio_search_path ());
6745 case DataType::MIDI:
6746 sp += Searchpath (config.get_midi_search_path ());
6750 for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6751 /* No need to add this new directory if it has the same inode as
6752 an existing one; checking inode rather than name prevents duplicated
6753 directories when we are using symlinks.
6755 On Windows, I think we could just do if (*i == path) here.
6757 if (PBD::equivalent_paths (*i, path)) {
6765 case DataType::AUDIO:
6766 config.set_audio_search_path (sp.to_string());
6768 case DataType::MIDI:
6769 config.set_midi_search_path (sp.to_string());
6775 Session::remove_dir_from_search_path (const string& dir, DataType type)
6780 case DataType::AUDIO:
6781 sp = Searchpath(config.get_audio_search_path ());
6783 case DataType::MIDI:
6784 sp = Searchpath (config.get_midi_search_path ());
6791 case DataType::AUDIO:
6792 config.set_audio_search_path (sp.to_string());
6794 case DataType::MIDI:
6795 config.set_midi_search_path (sp.to_string());
6801 boost::shared_ptr<Speakers>
6802 Session::get_speakers()
6808 Session::unknown_processors () const
6812 boost::shared_ptr<RouteList> r = routes.reader ();
6813 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6814 list<string> t = (*i)->unknown_processors ();
6815 copy (t.begin(), t.end(), back_inserter (p));
6825 Session::update_latency (bool playback)
6828 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6830 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6833 if (!_engine.running()) {
6837 boost::shared_ptr<RouteList> r = routes.reader ();
6838 framecnt_t max_latency = 0;
6841 /* reverse the list so that we work backwards from the last route to run to the first */
6842 RouteList* rl = routes.reader().get();
6843 r.reset (new RouteList (*rl));
6844 reverse (r->begin(), r->end());
6847 /* compute actual latency values for the given direction and store them all in per-port
6848 structures. this will also publish the same values (to JACK) so that computation of latency
6849 for routes can consistently use public latency values.
6852 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6853 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6856 /* because we latency compensate playback, our published playback latencies should
6857 be the same for all output ports - all material played back by ardour has
6858 the same latency, whether its caused by plugins or by latency compensation. since
6859 these may differ from the values computed above, reset all playback port latencies
6863 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6865 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6866 (*i)->set_public_port_latencies (max_latency, playback);
6871 post_playback_latency ();
6875 post_capture_latency ();
6878 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6882 Session::post_playback_latency ()
6884 set_worst_playback_latency ();
6886 boost::shared_ptr<RouteList> r = routes.reader ();
6888 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6889 if (!(*i)->is_auditioner() && ((*i)->active())) {
6890 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6894 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6895 (*i)->set_latency_compensation (_worst_track_latency);
6900 Session::post_capture_latency ()
6902 set_worst_capture_latency ();
6904 /* reflect any changes in capture latencies into capture offsets
6907 boost::shared_ptr<RouteList> rl = routes.reader();
6908 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6909 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6911 tr->set_capture_offset ();
6917 Session::initialize_latencies ()
6920 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6921 update_latency (false);
6922 update_latency (true);
6925 set_worst_io_latencies ();
6929 Session::set_worst_io_latencies ()
6931 set_worst_playback_latency ();
6932 set_worst_capture_latency ();
6936 Session::set_worst_playback_latency ()
6938 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6942 _worst_output_latency = 0;
6944 if (!_engine.connected()) {
6948 boost::shared_ptr<RouteList> r = routes.reader ();
6950 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6951 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6954 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6958 Session::set_worst_capture_latency ()
6960 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6964 _worst_input_latency = 0;
6966 if (!_engine.connected()) {
6970 boost::shared_ptr<RouteList> r = routes.reader ();
6972 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6973 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6976 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6980 Session::update_latency_compensation (bool force_whole_graph)
6982 bool some_track_latency_changed = false;
6984 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6988 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6990 _worst_track_latency = 0;
6992 boost::shared_ptr<RouteList> r = routes.reader ();
6994 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6995 if (!(*i)->is_auditioner() && ((*i)->active())) {
6997 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6998 some_track_latency_changed = true;
7000 _worst_track_latency = max (tl, _worst_track_latency);
7004 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
7005 (some_track_latency_changed ? "yes" : "no")));
7007 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
7009 if (some_track_latency_changed || force_whole_graph) {
7010 _engine.update_latencies ();
7014 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7015 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
7019 tr->set_capture_offset ();
7024 Session::session_name_is_legal (const string& path)
7026 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
7028 for (int i = 0; illegal_chars[i]; ++i) {
7029 if (path.find (illegal_chars[i]) != string::npos) {
7030 return illegal_chars[i];
7038 Session::notify_presentation_info_change ()
7040 if (deletion_in_progress()) {
7044 reassign_track_numbers();
7046 #ifdef USE_TRACKS_CODE_FEATURES
7047 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
7048 * if track order has been changed by user
7050 reconnect_existing_routes(true, true);
7056 Session::operation_in_progress (GQuark op) const
7058 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
7061 boost::shared_ptr<Port>
7062 Session::ltc_input_port () const
7064 return _ltc_input->nth (0);
7067 boost::shared_ptr<Port>
7068 Session::ltc_output_port () const
7070 return _ltc_output->nth (0);
7074 Session::reconnect_ltc_input ()
7078 string src = Config->get_ltc_source_port();
7080 _ltc_input->disconnect (this);
7082 if (src != _("None") && !src.empty()) {
7083 _ltc_input->nth (0)->connect (src);
7086 if ( ARDOUR::Profile->get_trx () ) {
7087 // Tracks need this signal to update timecode_source_dropdown
7088 MtcOrLtcInputPortChanged (); //emit signal
7094 Session::reconnect_ltc_output ()
7098 string src = Config->get_ltc_output_port();
7100 _ltc_output->disconnect (this);
7102 if (src != _("None") && !src.empty()) {
7103 _ltc_output->nth (0)->connect (src);
7109 Session::set_range_selection (framepos_t start, framepos_t end)
7111 _range_selection = Evoral::Range<framepos_t> (start, end);
7112 #ifdef USE_TRACKS_CODE_FEATURES
7113 follow_playhead_priority ();
7118 Session::set_object_selection (framepos_t start, framepos_t end)
7120 _object_selection = Evoral::Range<framepos_t> (start, end);
7121 #ifdef USE_TRACKS_CODE_FEATURES
7122 follow_playhead_priority ();
7127 Session::clear_range_selection ()
7129 _range_selection = Evoral::Range<framepos_t> (-1,-1);
7130 #ifdef USE_TRACKS_CODE_FEATURES
7131 follow_playhead_priority ();
7136 Session::clear_object_selection ()
7138 _object_selection = Evoral::Range<framepos_t> (-1,-1);
7139 #ifdef USE_TRACKS_CODE_FEATURES
7140 follow_playhead_priority ();
7145 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
7146 const ChanCount& input_start,
7147 const ChanCount& output_start,
7148 const ChanCount& input_offset,
7149 const ChanCount& output_offset)
7151 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7152 _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
7153 input_start, output_start,
7154 input_offset, output_offset));
7156 auto_connect_thread_wakeup ();
7160 Session::auto_connect_thread_wakeup ()
7162 if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
7163 pthread_cond_signal (&_auto_connect_cond);
7164 pthread_mutex_unlock (&_auto_connect_mutex);
7169 Session::queue_latency_recompute ()
7171 g_atomic_int_inc (&_latency_recompute_pending);
7172 auto_connect_thread_wakeup ();
7176 Session::auto_connect (const AutoConnectRequest& ar)
7178 boost::shared_ptr<Route> route = ar.route.lock();
7180 if (!route) { return; }
7182 if (!IO::connecting_legal) {
7186 /* If both inputs and outputs are auto-connected to physical ports,
7187 * use the max of input and output offsets to ensure auto-connected
7188 * port numbers always match up (e.g. the first audio input and the
7189 * first audio output of the route will have the same physical
7190 * port number). Otherwise just use the lowest input or output
7194 const bool in_out_physical =
7195 (Config->get_input_auto_connect() & AutoConnectPhysical)
7196 && (Config->get_output_auto_connect() & AutoConnectPhysical)
7197 && ar.connect_inputs;
7199 const ChanCount in_offset = in_out_physical
7200 ? ChanCount::max(ar.input_offset, ar.output_offset)
7203 const ChanCount out_offset = in_out_physical
7204 ? ChanCount::max(ar.input_offset, ar.output_offset)
7207 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
7208 vector<string> physinputs;
7209 vector<string> physoutputs;
7212 /* for connecting track inputs we only want MIDI ports marked
7216 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
7218 if (!physinputs.empty() && ar.connect_inputs) {
7219 uint32_t nphysical_in = physinputs.size();
7221 for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
7224 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
7225 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
7228 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
7234 if (!physoutputs.empty()) {
7235 uint32_t nphysical_out = physoutputs.size();
7236 for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
7240 * do not create new connections if we reached the limit of physical outputs
7243 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
7244 ARDOUR::Profile->get_trx () &&
7245 ar.output_offset.get(*t) == nphysical_out ) {
7249 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
7250 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
7251 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
7252 /* master bus is audio only */
7253 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
7254 port = _master_out->input()->ports().port(*t,
7255 i % _master_out->input()->n_ports().get(*t))->name();
7259 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
7268 Session::auto_connect_thread_start ()
7270 if (g_atomic_int_get (&_ac_thread_active)) {
7274 while (!_auto_connect_queue.empty ()) {
7275 _auto_connect_queue.pop ();
7278 g_atomic_int_set (&_ac_thread_active, 1);
7279 if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7280 g_atomic_int_set (&_ac_thread_active, 0);
7285 Session::auto_connect_thread_terminate ()
7287 if (!g_atomic_int_get (&_ac_thread_active)) {
7292 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7293 while (!_auto_connect_queue.empty ()) {
7294 _auto_connect_queue.pop ();
7298 /* cannot use auto_connect_thread_wakeup() because that is allowed to
7299 * fail to wakeup the thread.
7302 pthread_mutex_lock (&_auto_connect_mutex);
7303 g_atomic_int_set (&_ac_thread_active, 0);
7304 pthread_cond_signal (&_auto_connect_cond);
7305 pthread_mutex_unlock (&_auto_connect_mutex);
7308 pthread_join (_auto_connect_thread, &status);
7312 Session::auto_connect_thread (void *arg)
7314 Session *s = static_cast<Session *>(arg);
7315 s->auto_connect_thread_run ();
7321 Session::auto_connect_thread_run ()
7323 pthread_set_name (X_("autoconnect"));
7324 SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7325 PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7326 pthread_mutex_lock (&_auto_connect_mutex);
7327 while (g_atomic_int_get (&_ac_thread_active)) {
7329 if (!_auto_connect_queue.empty ()) {
7330 // Why would we need the process lock ??
7331 // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7332 // graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7333 // All ardour-internal backends use a std::vector xxxAudioBackend::find_port()
7334 // We have control over those, but what does jack do?
7335 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7337 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7338 while (!_auto_connect_queue.empty ()) {
7339 const AutoConnectRequest ar (_auto_connect_queue.front());
7340 _auto_connect_queue.pop ();
7347 if (!actively_recording ()) { // might not be needed,
7348 /* this is only used for updating plugin latencies, the
7349 * graph does not change. so it's safe in general.
7351 * .. update_latency_compensation () entails set_capture_offset()
7352 * which calls Diskstream::set_capture_offset () which
7353 * modifies the capture offset... which can be a proplem
7354 * in "prepare_to_stop"
7356 while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7357 update_latency_compensation ();
7362 // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7363 // jack1 cannot cope with removing ports while processing
7364 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7365 AudioEngine::instance()->clear_pending_port_deletions ();
7368 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7370 pthread_mutex_unlock (&_auto_connect_mutex);
7374 Session::cancel_all_solo ()
7378 get_stripables (sl);
7380 set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7381 clear_all_solo_state (routes.reader());