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/slave.h"
102 #include "ardour/smf_source.h"
103 #include "ardour/solo_isolate_control.h"
104 #include "ardour/source_factory.h"
105 #include "ardour/speakers.h"
106 #include "ardour/tempo.h"
107 #include "ardour/ticker.h"
108 #include "ardour/track.h"
109 #include "ardour/types_convert.h"
110 #include "ardour/user_bundle.h"
111 #include "ardour/utils.h"
112 #include "ardour/vca_manager.h"
113 #include "ardour/vca.h"
115 #include "midi++/port.h"
116 #include "midi++/mmc.h"
118 #include "LuaBridge/LuaBridge.h"
120 #include "pbd/i18n.h"
122 #include <glibmm/checksum.h>
131 using namespace ARDOUR;
134 bool Session::_disable_all_loaded_plugins = false;
135 bool Session::_bypass_all_loaded_plugins = false;
136 guint Session::_name_id_counter = 0;
138 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
139 PBD::Signal1<void,std::string> Session::Dialog;
140 PBD::Signal0<int> Session::AskAboutPendingState;
141 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
142 PBD::Signal2<void, framecnt_t, framecnt_t> Session::NotifyAboutSampleRateMismatch;
143 PBD::Signal0<void> Session::SendFeedback;
144 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
146 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
147 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
148 PBD::Signal2<void,std::string, std::string> Session::Exported;
149 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
150 PBD::Signal0<void> Session::Quit;
151 PBD::Signal0<void> Session::FeedbackDetected;
152 PBD::Signal0<void> Session::SuccessfulGraphSort;
153 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
155 const framecnt_t Session::bounce_chunk_size = 8192;
156 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
157 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
159 // seconds should be added after the region exceeds end marker
160 #ifdef USE_TRACKS_CODE_FEATURES
161 const uint32_t Session::session_end_shift = 5;
163 const uint32_t Session::session_end_shift = 0;
166 /** @param snapshot_name Snapshot name, without .ardour suffix */
167 Session::Session (AudioEngine &eng,
168 const string& fullpath,
169 const string& snapshot_name,
170 BusProfile* bus_profile,
172 : playlists (new SessionPlaylists)
174 , process_function (&Session::process_with_events)
175 , _bounce_processing_active (false)
176 , waiting_for_sync_offset (false)
177 , _base_frame_rate (0)
178 , _nominal_frame_rate (0)
179 , _current_frame_rate (0)
180 , transport_sub_state (0)
181 , _record_status (Disabled)
182 , _transport_frame (0)
183 , _session_range_location (0)
184 , _session_range_end_is_free (true)
187 , _transport_speed (0)
188 , _default_transport_speed (1.0)
189 , _last_transport_speed (0)
190 , _signalled_varispeed (0)
191 , _target_transport_speed (0.0)
192 , auto_play_legal (false)
193 , _last_slave_transport_frame (0)
194 , maximum_output_latency (0)
195 , _requested_return_frame (-1)
196 , current_block_size (0)
197 , _worst_output_latency (0)
198 , _worst_input_latency (0)
199 , _worst_track_latency (0)
200 , _have_captured (false)
201 , _non_soloed_outs_muted (false)
204 , _solo_isolated_cnt (0)
206 , _was_seamless (Config->get_seamless_loop ())
207 , _under_nsm_control (false)
209 , delta_accumulator_cnt (0)
210 , average_slave_delta (1800) // !!! why 1800 ???
212 , have_first_delta_accumulator (false)
213 , _slave_state (Stopped)
214 , _mtc_active (false)
215 , _ltc_active (false)
216 , post_export_sync (false)
217 , post_export_position (0)
219 , _export_rolling (false)
220 , _realtime_export (false)
221 , _region_export (false)
222 , _export_preroll (0)
223 , _export_latency (0)
224 , _pre_export_mmc_enabled (false)
225 , _name (snapshot_name)
227 , _send_qf_mtc (false)
228 , _pframes_since_last_mtc (0)
230 , loop_changing (false)
232 , _session_dir (new SessionDirectory (fullpath))
233 , _current_snapshot_name (snapshot_name)
235 , state_was_pending (false)
236 , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
238 , _save_queued (false)
239 , _last_roll_location (0)
240 , _last_roll_or_reversal_location (0)
241 , _last_record_location (0)
242 , pending_locate_roll (false)
243 , pending_locate_frame (0)
244 , pending_locate_flush (false)
245 , pending_abort (false)
246 , pending_auto_loop (false)
247 , _mempool ("Session", 3145728)
248 , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
250 , _butler (new Butler (*this))
251 , _post_transport_work (0)
252 , cumulative_rf_motion (0)
254 , _locations (new Locations (*this))
255 , _ignore_skips_updates (false)
256 , _rt_thread_active (false)
257 , _rt_emit_pending (false)
258 , _ac_thread_active (0)
259 , _latency_recompute_pending (0)
261 , outbound_mtc_timecode_frame (0)
262 , next_quarter_frame_to_send (-1)
263 , _samples_per_timecode_frame (0)
264 , _frames_per_hour (0)
265 , _timecode_frames_per_hour (0)
266 , last_timecode_valid (false)
267 , last_timecode_when (0)
268 , _send_timecode_update (false)
280 , ltc_timecode_offset (0)
281 , ltc_timecode_negative_offset (false)
282 , midi_control_ui (0)
284 , _all_route_group (new RouteGroup (*this, "all"))
285 , routes (new RouteList)
286 , _adding_routes_in_progress (false)
287 , _reconnecting_routes_in_progress (false)
288 , _route_deletion_in_progress (false)
289 , destructive_index (0)
290 , _track_number_decimals(1)
291 , default_fade_steepness (0)
292 , default_fade_msecs (0)
293 , _total_free_4k_blocks (0)
294 , _total_free_4k_blocks_uncertain (false)
295 , no_questions_about_missing_files (false)
298 , _bundles (new BundleList)
299 , _bundle_xml_node (0)
302 , _click_rec_only (false)
304 , click_emphasis_data (0)
306 , click_emphasis_length (0)
307 , _clicks_cleared (0)
308 , _count_in_samples (0)
309 , _play_range (false)
310 , _range_selection (-1,-1)
311 , _object_selection (-1,-1)
312 , _preroll_record_punch_pos (-1)
313 , _preroll_record_trim_len (0)
314 , _count_in_once (false)
316 , first_file_data_format_reset (true)
317 , first_file_header_format_reset (true)
318 , have_looped (false)
319 , _have_rec_enabled_track (false)
320 , _have_rec_disabled_track (true)
322 , _suspend_timecode_transmission (0)
323 , _speakers (new Speakers)
324 , _ignore_route_processor_changes (0)
329 , _vca_manager (new VCAManager (*this))
330 , _selection (new CoreSelection (*this))
334 created_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
336 pthread_mutex_init (&_rt_emit_mutex, 0);
337 pthread_cond_init (&_rt_emit_cond, 0);
339 pthread_mutex_init (&_auto_connect_mutex, 0);
340 pthread_cond_init (&_auto_connect_cond, 0);
342 init_name_id_counter (1); // reset for new sessions, start at 1
343 VCA::set_next_vca_number (1); // reset for new sessions, start at 1
345 pre_engine_init (fullpath); // sets _is_new
351 Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
353 #ifdef USE_TRACKS_CODE_FEATURES
354 sr = EngineStateController::instance()->get_current_sample_rate();
356 if (ensure_engine (sr, true)) {
358 throw SessionException (_("Cannot connect to audio/midi engine"));
361 // set samplerate for plugins added early
362 // e.g from templates or MB channelstrip
363 set_block_size (_engine.samples_per_cycle());
364 set_frame_rate (_engine.sample_rate());
366 if (create (mix_template, bus_profile)) {
368 throw SessionException (_("Session initialization failed"));
371 /* if a mix template was provided, then ::create() will
372 * have copied it into the session and we need to load it
373 * so that we have the state ready for ::set_state()
374 * after the engine is started.
376 * Note that we do NOT try to get the sample rate from
377 * the template at this time, though doing so would
378 * be easy if we decided this was an appropriate part
382 if (!mix_template.empty()) {
384 if (load_state (_current_snapshot_name)) {
385 throw SessionException (_("Failed to load template/snapshot state"));
387 } catch (PBD::unknown_enumeration& e) {
388 throw SessionException (_("Failed to parse template/snapshot state"));
390 store_recent_templates (mix_template);
393 /* load default session properties - if any */
398 if (load_state (_current_snapshot_name)) {
399 throw SessionException (_("Failed to load state"));
402 /* try to get sample rate from XML state so that we
403 * can influence the SR if we set up the audio
408 XMLProperty const * prop;
409 XMLNode const * root (state_tree->root());
410 if ((prop = root->property (X_("sample-rate"))) != 0) {
411 sr = atoi (prop->value());
415 if (ensure_engine (sr, false)) {
417 throw SessionException (_("Cannot connect to audio/midi engine"));
421 int err = post_engine_init ();
426 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Failed to create background threads.")));
430 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Invalid TempoMap in session-file.")));
433 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Invalid or corrupt session state.")));
436 throw SessionException (string_compose (_("Cannot initialize session/engine: %1"), _("Port registration failed.")));
439 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")));
444 store_recent_sessions (_name, _path);
446 bool was_dirty = dirty();
448 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
450 PresentationInfo::Change.connect_same_thread (*this, boost::bind (&Session::notify_presentation_info_change, this));
452 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
453 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
456 DirtyChanged (); /* EMIT SIGNAL */
459 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
460 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
462 emit_thread_start ();
463 auto_connect_thread_start ();
465 /* hook us up to the engine since we are now completely constructed */
467 BootMessage (_("Connect to engine"));
469 _engine.set_session (this);
470 _engine.reset_timebase ();
472 #ifdef USE_TRACKS_CODE_FEATURES
474 EngineStateController::instance()->set_session(this);
477 if ( ARDOUR::Profile->get_trx () ) {
479 /* Waves Tracks: fill session with tracks basing on the amount of inputs.
480 * each available input must have corresponding track when session starts.
483 uint32_t how_many (0);
485 std::vector<std::string> inputs;
486 EngineStateController::instance()->get_physical_audio_inputs(inputs);
488 how_many = inputs.size();
490 list<boost::shared_ptr<AudioTrack> > tracks;
492 // Track names after driver
493 if (Config->get_tracks_auto_naming() == NameAfterDriver) {
494 string track_name = "";
495 for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
497 track_name = inputs[i];
498 replace_all (track_name, "system:capture", "");
500 list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
501 tracks.insert(tracks.begin(), single_track.front());
503 } else { // Default track names
504 tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
507 if (tracks.size() != how_many) {
509 throw failed_constructor ();
515 ensure_subdirs (); // archived or zipped sessions may lack peaks/ analysis/ etc
517 if (!mix_template.empty ()) {
518 /* ::create() unsets _is_new after creating the session.
519 * But for templated sessions, the sample-rate is initially unset
520 * (not read from template), so we need to save it (again).
528 BootMessage (_("Session loading complete"));
540 Session::next_name_id ()
542 return g_atomic_int_add (&_name_id_counter, 1);
546 Session::name_id_counter ()
548 return g_atomic_int_get (&_name_id_counter);
552 Session::init_name_id_counter (guint n)
554 g_atomic_int_set (&_name_id_counter, n);
558 Session::ensure_engine (uint32_t desired_sample_rate, bool isnew)
560 if (_engine.current_backend() == 0) {
561 /* backend is unknown ... */
562 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
563 if (r.get_value_or (-1) != 0) {
566 } else if (!isnew && _engine.running() && _engine.sample_rate () == desired_sample_rate) {
568 } else if (_engine.setup_required()) {
569 /* backend is known, but setup is needed */
570 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
571 if (r.get_value_or (-1) != 0) {
574 } else if (!_engine.running()) {
575 if (_engine.start()) {
580 /* at this point the engine should be running */
582 if (!_engine.running()) {
586 return immediately_post_engine ();
591 Session::immediately_post_engine ()
593 /* Do various initializations that should take place directly after we
594 * know that the engine is running, but before we either create a
595 * session or set state for an existing one.
598 if (how_many_dsp_threads () > 1) {
599 /* For now, only create the graph if we are using >1 DSP threads, as
600 it is a bit slower than the old code with 1 thread.
602 _process_graph.reset (new Graph (*this));
605 /* every time we reconnect, recompute worst case output latencies */
607 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
609 if (synced_to_engine()) {
610 _engine.transport_stop ();
613 if (config.get_jack_time_master()) {
614 _engine.transport_locate (_transport_frame);
618 BootMessage (_("Set up LTC"));
620 BootMessage (_("Set up Click"));
622 BootMessage (_("Set up standard connections"));
626 catch (failed_constructor& err) {
630 /* TODO, connect in different thread. (PortRegisteredOrUnregistered may be in RT context)
632 _engine.PortRegisteredOrUnregistered.connect_same_thread (*this, boost::bind (&Session::setup_bundles, this));
640 vector<void*> debug_pointers;
642 /* if we got to here, leaving pending capture state around
646 remove_pending_capture_state ();
650 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
653 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
659 /* disconnect from any and all signals that we are connected to */
661 Port::PortSignalDrop (); /* EMIT SIGNAL */
664 /* shutdown control surface protocols while we still have ports
665 * and the engine to move data to any devices.
668 /* remove I/O objects before unsetting the engine session */
671 _ltc_output.reset ();
673 ControlProtocolManager::instance().drop_protocols ();
675 /* stop auto dis/connecting */
676 auto_connect_thread_terminate ();
678 MIDI::Name::MidiPatchManager::instance().remove_search_path(session_directory().midi_patch_path());
680 _engine.remove_session ();
682 #ifdef USE_TRACKS_CODE_FEATURES
683 EngineStateController::instance()->remove_session();
686 /* deregister all ports - there will be no process or any other
687 * callbacks from the engine any more.
690 Port::PortDrop (); /* EMIT SIGNAL */
692 /* clear history so that no references to objects are held any more */
696 /* clear state tree so that no references to objects are held any more */
702 /* unregister all lua functions, drop held references (if any) */
703 Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
705 lua.do_command ("Session = nil");
713 lua.collect_garbage ();
716 /* reset dynamic state version back to default */
717 Stateful::loading_state_version = 0;
719 _butler->drop_references ();
723 delete _all_route_group;
725 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
726 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
730 if (click_data != default_click) {
731 delete [] click_data;
734 if (click_emphasis_data != default_click_emphasis) {
735 delete [] click_emphasis_data;
740 /* need to remove auditioner before monitoring section
741 * otherwise it is re-connected */
744 /* drop references to routes held by the monitoring section
745 * specifically _monitor_out aux/listen references */
746 remove_monitor_section();
748 /* clear out any pending dead wood from RCU managed objects */
753 AudioDiskstream::free_working_buffers();
755 /* tell everyone who is still standing that we're about to die */
758 /* tell everyone to drop references and delete objects as we go */
760 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
761 RegionFactory::delete_all_regions ();
763 /* Do this early so that VCAs no longer hold references to routes */
765 DEBUG_TRACE (DEBUG::Destruction, "delete vcas\n");
768 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
770 /* reset these three references to special routes before we do the usual route delete thing */
772 _master_out.reset ();
773 _monitor_out.reset ();
776 RCUWriter<RouteList> writer (routes);
777 boost::shared_ptr<RouteList> r = writer.get_copy ();
779 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
780 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
781 (*i)->drop_references ();
785 /* writer goes out of scope and updates master */
790 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
791 Glib::Threads::Mutex::Lock lm (source_lock);
792 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
793 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
794 i->second->drop_references ();
800 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
803 emit_thread_terminate ();
805 pthread_cond_destroy (&_rt_emit_cond);
806 pthread_mutex_destroy (&_rt_emit_mutex);
808 pthread_cond_destroy (&_auto_connect_cond);
809 pthread_mutex_destroy (&_auto_connect_mutex);
811 delete _scene_changer; _scene_changer = 0;
812 delete midi_control_ui; midi_control_ui = 0;
814 delete _mmc; _mmc = 0;
815 delete _midi_ports; _midi_ports = 0;
816 delete _locations; _locations = 0;
821 /* clear event queue, the session is gone, nobody is interested in
822 * those anymore, but they do leak memory if not removed
824 while (!immediate_events.empty ()) {
825 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
826 SessionEvent *ev = immediate_events.front ();
827 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Drop event: %1\n", enum_2_string (ev->type)));
828 immediate_events.pop_front ();
832 case SessionEvent::AutoLoop:
833 case SessionEvent::AutoLoopDeclick:
834 case SessionEvent::Skip:
835 case SessionEvent::PunchIn:
836 case SessionEvent::PunchOut:
837 case SessionEvent::RecordStart:
838 case SessionEvent::StopOnce:
839 case SessionEvent::RangeStop:
840 case SessionEvent::RangeLocate:
844 case SessionEvent::RealTimeOperation:
851 del = del && !_remove_event (ev);
859 /* unregister all dropped ports, process pending port deletion. */
860 // this may call ARDOUR::Port::drop ... jack_port_unregister ()
861 // jack1 cannot cope with removing ports while processing
862 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
863 AudioEngine::instance()->clear_pending_port_deletions ();
866 DEBUG_TRACE (DEBUG::Destruction, "delete selection\n");
870 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
872 BOOST_SHOW_POINTERS ();
876 Session::setup_ltc ()
880 _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
881 _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
883 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
884 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
887 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
888 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
889 // TODO use auto-connect thread somehow (needs a route currently)
890 // see note in Session::auto_connect_thread_run() why process lock is needed.
891 reconnect_ltc_input ();
895 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
896 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
899 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
900 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
901 // TODO use auto-connect thread
902 reconnect_ltc_output ();
906 /* fix up names of LTC ports because we don't want the normal
907 * IO style of NAME/TYPE-{in,out}N
910 _ltc_input->nth (0)->set_name (X_("LTC-in"));
911 _ltc_output->nth (0)->set_name (X_("LTC-out"));
915 Session::setup_click ()
919 boost::shared_ptr<AutomationList> gl (new AutomationList (Evoral::Parameter (GainAutomation)));
920 boost::shared_ptr<GainControl> gain_control = boost::shared_ptr<GainControl> (new GainControl (*this, Evoral::Parameter(GainAutomation), gl));
922 _click_io.reset (new ClickIO (*this, X_("Click")));
923 _click_gain.reset (new Amp (*this, _("Fader"), gain_control, true));
924 _click_gain->activate ();
926 setup_click_state (state_tree->root());
928 setup_click_state (0);
933 Session::setup_click_state (const XMLNode* node)
935 const XMLNode* child = 0;
937 if (node && (child = find_named_node (*node, "Click")) != 0) {
939 /* existing state for Click */
942 if (Stateful::loading_state_version < 3000) {
943 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
945 const XMLNodeList& children (child->children());
946 XMLNodeList::const_iterator i = children.begin();
947 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
949 if (i != children.end()) {
950 c = _click_gain->set_state (**i, Stateful::loading_state_version);
956 _clicking = Config->get_clicking ();
960 error << _("could not setup Click I/O") << endmsg;
967 /* default state for Click: dual-mono to first 2 physical outputs */
970 _engine.get_physical_outputs (DataType::AUDIO, outs);
972 for (uint32_t physport = 0; physport < 2; ++physport) {
973 if (outs.size() > physport) {
974 if (_click_io->add_port (outs[physport], this)) {
975 // relax, even though its an error
980 if (_click_io->n_ports () > ChanCount::ZERO) {
981 _clicking = Config->get_clicking ();
987 Session::get_physical_ports (vector<string>& inputs, vector<string>& outputs, DataType type,
988 MidiPortFlags include, MidiPortFlags exclude)
990 _engine.get_physical_inputs (type, inputs, include, exclude);
991 _engine.get_physical_outputs (type, outputs, include, exclude);
995 Session::setup_bundles ()
999 RCUWriter<BundleList> writer (_bundles);
1000 boost::shared_ptr<BundleList> b = writer.get_copy ();
1001 for (BundleList::iterator i = b->begin(); i != b->end();) {
1002 if (boost::dynamic_pointer_cast<UserBundle>(*i)) {
1010 vector<string> inputs[DataType::num_types];
1011 vector<string> outputs[DataType::num_types];
1013 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1014 get_physical_ports (inputs[i], outputs[i], DataType (DataType::Symbol (i)),
1015 MidiPortFlags (0), /* no specific inclusions */
1016 MidiPortFlags (MidiPortControl|MidiPortVirtual) /* exclude control & virtual ports */
1020 /* Create a set of Bundle objects that map
1021 to the physical I/O currently available. We create both
1022 mono and stereo bundles, so that the common cases of mono
1023 and stereo tracks get bundles to put in their mixer strip
1024 in / out menus. There may be a nicer way of achieving that;
1025 it doesn't really scale that well to higher channel counts
1028 /* mono output bundles */
1030 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
1032 std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
1034 snprintf (buf, sizeof (buf), _("out %s"), pn.c_str());
1036 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
1039 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
1040 c->add_channel (_("mono"), DataType::AUDIO);
1041 c->set_port (0, outputs[DataType::AUDIO][np]);
1043 add_bundle (c, false);
1046 /* stereo output bundles */
1048 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
1049 if (np + 1 < outputs[DataType::AUDIO].size()) {
1051 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1052 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
1053 c->add_channel (_("L"), DataType::AUDIO);
1054 c->set_port (0, outputs[DataType::AUDIO][np]);
1055 c->add_channel (_("R"), DataType::AUDIO);
1056 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
1058 add_bundle (c, false);
1062 /* mono input bundles */
1064 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
1066 std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
1068 snprintf (buf, sizeof (buf), _("in %s"), pn.c_str());
1070 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
1073 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1074 c->add_channel (_("mono"), DataType::AUDIO);
1075 c->set_port (0, inputs[DataType::AUDIO][np]);
1077 add_bundle (c, false);
1080 /* stereo input bundles */
1082 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
1083 if (np + 1 < inputs[DataType::AUDIO].size()) {
1085 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1087 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1088 c->add_channel (_("L"), DataType::AUDIO);
1089 c->set_port (0, inputs[DataType::AUDIO][np]);
1090 c->add_channel (_("R"), DataType::AUDIO);
1091 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
1093 add_bundle (c, false);
1097 /* MIDI input bundles */
1099 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
1100 string n = inputs[DataType::MIDI][np];
1102 std::string pn = _engine.get_pretty_name_by_name (n);
1106 boost::erase_first (n, X_("alsa_pcm:"));
1108 boost::shared_ptr<Bundle> c (new Bundle (n, false));
1109 c->add_channel ("", DataType::MIDI);
1110 c->set_port (0, inputs[DataType::MIDI][np]);
1111 add_bundle (c, false);
1114 /* MIDI output bundles */
1116 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
1117 string n = outputs[DataType::MIDI][np];
1118 std::string pn = _engine.get_pretty_name_by_name (n);
1122 boost::erase_first (n, X_("alsa_pcm:"));
1124 boost::shared_ptr<Bundle> c (new Bundle (n, true));
1125 c->add_channel ("", DataType::MIDI);
1126 c->set_port (0, outputs[DataType::MIDI][np]);
1127 add_bundle (c, false);
1130 // we trust the backend to only calls us if there's a change
1131 BundleAddedOrRemoved (); /* EMIT SIGNAL */
1135 Session::auto_connect_master_bus ()
1137 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
1141 // Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
1142 // In this case it means "Multi Out" output mode
1143 if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
1147 /* if requested auto-connect the outputs to the first N physical ports.
1150 uint32_t limit = _master_out->n_outputs().n_total();
1151 vector<string> outputs[DataType::num_types];
1153 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1154 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1157 for (uint32_t n = 0; n < limit; ++n) {
1158 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
1160 if (outputs[p->type()].size() > n) {
1161 connect_to = outputs[p->type()][n];
1164 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
1165 if (_master_out->output()->connect (p, connect_to, this)) {
1166 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
1175 Session::remove_monitor_section ()
1177 if (!_monitor_out || Profile->get_trx()) {
1181 /* force reversion to Solo-In-Place */
1182 Config->set_solo_control_is_listen_control (false);
1184 /* if we are auditioning, cancel it ... this is a workaround
1185 to a problem (auditioning does not execute the process graph,
1186 which is needed to remove routes when using >1 core for processing)
1191 /* Hold process lock while doing this so that we don't hear bits and
1192 * pieces of audio as we work on each route.
1195 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1197 /* Connect tracks to monitor section. Note that in an
1198 existing session, the internal sends will already exist, but we want the
1199 routes to notice that they connect to the control out specifically.
1203 boost::shared_ptr<RouteList> r = routes.reader ();
1204 ProcessorChangeBlocker pcb (this, false);
1206 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
1208 if ((*x)->is_monitor()) {
1210 } else if ((*x)->is_master()) {
1213 (*x)->remove_aux_or_listen (_monitor_out);
1218 remove_route (_monitor_out);
1219 if (_state_of_the_state & Deletion) {
1223 auto_connect_master_bus ();
1226 auditioner->connect ();
1229 Config->ParameterChanged ("use-monitor-bus");
1233 Session::add_monitor_section ()
1237 if (_monitor_out || !_master_out || Profile->get_trx()) {
1241 boost::shared_ptr<Route> r (new Route (*this, _("Monitor"), PresentationInfo::MonitorOut, DataType::AUDIO));
1247 BOOST_MARK_ROUTE(r);
1250 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1251 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1252 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1254 error << _("Cannot create monitor section. 'Monitor' Port name is not unique.") << endmsg;
1259 add_routes (rl, false, false, false, 0);
1261 assert (_monitor_out);
1263 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
1264 are undefined, at best.
1267 uint32_t limit = _monitor_out->n_inputs().n_audio();
1271 /* connect the inputs to the master bus outputs. this
1272 * represents a separate data feed from the internal sends from
1273 * each route. as of jan 2011, it allows the monitor section to
1274 * conditionally ignore either the internal sends or the normal
1275 * input feed, but we should really find a better way to do
1279 _master_out->output()->disconnect (this);
1281 for (uint32_t n = 0; n < limit; ++n) {
1282 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1283 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1286 string connect_to = o->name();
1287 if (_monitor_out->input()->connect (p, connect_to, this)) {
1288 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1296 /* if monitor section is not connected, connect it to physical outs
1299 if ((Config->get_auto_connect_standard_busses () || Profile->get_mixbus ()) && !_monitor_out->output()->connected ()) {
1301 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1303 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1306 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1308 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1309 Config->get_monitor_bus_preferred_bundle())
1315 /* Monitor bus is audio only */
1317 vector<string> outputs[DataType::num_types];
1319 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1320 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1323 uint32_t mod = outputs[DataType::AUDIO].size();
1324 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1328 for (uint32_t n = 0; n < limit; ++n) {
1330 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1332 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1333 connect_to = outputs[DataType::AUDIO][n % mod];
1336 if (!connect_to.empty()) {
1337 if (_monitor_out->output()->connect (p, connect_to, this)) {
1338 error << string_compose (
1339 _("cannot connect control output %1 to %2"),
1350 /* Hold process lock while doing this so that we don't hear bits and
1351 * pieces of audio as we work on each route.
1354 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1356 /* Connect tracks to monitor section. Note that in an
1357 existing session, the internal sends will already exist, but we want the
1358 routes to notice that they connect to the control out specifically.
1362 boost::shared_ptr<RouteList> rls = routes.reader ();
1364 ProcessorChangeBlocker pcb (this, false /* XXX */);
1366 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1368 if ((*x)->is_monitor()) {
1370 } else if ((*x)->is_master()) {
1373 (*x)->enable_monitor_send ();
1378 auditioner->connect ();
1380 Config->ParameterChanged ("use-monitor-bus");
1384 Session::reset_monitor_section ()
1386 /* Process lock should be held by the caller.*/
1388 if (!_monitor_out || Profile->get_trx()) {
1392 uint32_t limit = _master_out->n_outputs().n_audio();
1394 /* connect the inputs to the master bus outputs. this
1395 * represents a separate data feed from the internal sends from
1396 * each route. as of jan 2011, it allows the monitor section to
1397 * conditionally ignore either the internal sends or the normal
1398 * input feed, but we should really find a better way to do
1402 _master_out->output()->disconnect (this);
1403 _monitor_out->output()->disconnect (this);
1405 // monitor section follow master bus - except midi
1406 ChanCount mon_chn (_master_out->output()->n_ports());
1407 mon_chn.set_midi (0);
1409 _monitor_out->input()->ensure_io (mon_chn, false, this);
1410 _monitor_out->output()->ensure_io (mon_chn, false, this);
1412 for (uint32_t n = 0; n < limit; ++n) {
1413 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1414 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1417 string connect_to = o->name();
1418 if (_monitor_out->input()->connect (p, connect_to, this)) {
1419 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1426 /* connect monitor section to physical outs
1429 if (Config->get_auto_connect_standard_busses()) {
1431 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1433 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1436 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1438 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1439 Config->get_monitor_bus_preferred_bundle())
1445 /* Monitor bus is audio only */
1447 vector<string> outputs[DataType::num_types];
1449 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1450 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1453 uint32_t mod = outputs[DataType::AUDIO].size();
1454 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1458 for (uint32_t n = 0; n < limit; ++n) {
1460 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1462 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1463 connect_to = outputs[DataType::AUDIO][n % mod];
1466 if (!connect_to.empty()) {
1467 if (_monitor_out->output()->connect (p, connect_to, this)) {
1468 error << string_compose (
1469 _("cannot connect control output %1 to %2"),
1480 /* Connect tracks to monitor section. Note that in an
1481 existing session, the internal sends will already exist, but we want the
1482 routes to notice that they connect to the control out specifically.
1486 boost::shared_ptr<RouteList> rls = routes.reader ();
1488 ProcessorChangeBlocker pcb (this, false);
1490 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1492 if ((*x)->is_monitor()) {
1494 } else if ((*x)->is_master()) {
1497 (*x)->enable_monitor_send ();
1503 Session::add_master_bus (ChanCount const& count)
1505 if (master_out ()) {
1511 boost::shared_ptr<Route> r (new Route (*this, _("Master"), PresentationInfo::MasterOut, DataType::AUDIO));
1516 BOOST_MARK_ROUTE(r);
1519 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1520 r->input()->ensure_io (count, false, this);
1521 r->output()->ensure_io (count, false, this);
1525 add_routes (rl, false, false, false, PresentationInfo::max_order);
1530 Session::hookup_io ()
1532 /* stop graph reordering notifications from
1533 causing resorts, etc.
1536 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1540 /* we delay creating the auditioner till now because
1541 it makes its own connections to ports.
1545 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1547 throw failed_constructor ();
1549 a->use_new_diskstream ();
1553 catch (failed_constructor& err) {
1554 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1558 /* load bundles, which we may have postponed earlier on */
1559 if (_bundle_xml_node) {
1560 load_bundles (*_bundle_xml_node);
1561 delete _bundle_xml_node;
1564 /* Tell all IO objects to connect themselves together */
1566 IO::enable_connecting ();
1568 /* Now tell all "floating" ports to connect to whatever
1569 they should be connected to.
1572 AudioEngine::instance()->reconnect_ports ();
1574 /* Anyone who cares about input state, wake up and do something */
1576 IOConnectionsComplete (); /* EMIT SIGNAL */
1578 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1580 /* now handle the whole enchilada as if it was one
1581 graph reorder event.
1586 /* update the full solo state, which can't be
1587 correctly determined on a per-route basis, but
1588 needs the global overview that only the session
1592 update_route_solo_state ();
1596 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1598 boost::shared_ptr<Track> track = wp.lock ();
1603 boost::shared_ptr<Playlist> playlist;
1605 if ((playlist = track->playlist()) != 0) {
1606 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1607 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1608 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1613 Session::record_enabling_legal () const
1615 /* this used to be in here, but survey says.... we don't need to restrict it */
1616 // if (record_status() == Recording) {
1620 if (Config->get_all_safe()) {
1627 Session::set_track_monitor_input_status (bool yn)
1629 boost::shared_ptr<RouteList> rl = routes.reader ();
1630 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1631 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1632 if (tr && tr->rec_enable_control()->get_value()) {
1633 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1634 tr->request_input_monitoring (yn);
1640 Session::auto_punch_start_changed (Location* location)
1642 replace_event (SessionEvent::PunchIn, location->start());
1644 if (get_record_enabled() && config.get_punch_in()) {
1645 /* capture start has been changed, so save new pending state */
1646 save_state ("", true);
1651 Session::auto_punch_end_changed (Location* location)
1653 framepos_t when_to_stop = location->end();
1654 // when_to_stop += _worst_output_latency + _worst_input_latency;
1655 replace_event (SessionEvent::PunchOut, when_to_stop);
1659 Session::auto_punch_changed (Location* location)
1661 framepos_t when_to_stop = location->end();
1663 replace_event (SessionEvent::PunchIn, location->start());
1664 //when_to_stop += _worst_output_latency + _worst_input_latency;
1665 replace_event (SessionEvent::PunchOut, when_to_stop);
1668 /** @param loc A loop location.
1669 * @param pos Filled in with the start time of the required fade-out (in session frames).
1670 * @param length Filled in with the length of the required fade-out.
1673 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1675 pos = max (loc->start(), loc->end() - 64);
1676 length = loc->end() - pos;
1680 Session::auto_loop_changed (Location* location)
1682 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1685 auto_loop_declick_range (location, dcp, dcl);
1687 if (transport_rolling() && play_loop) {
1689 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1691 // if (_transport_frame > location->end()) {
1693 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1694 // relocate to beginning of loop
1695 clear_events (SessionEvent::LocateRoll);
1697 request_locate (location->start(), true);
1700 else if (Config->get_seamless_loop() && !loop_changing) {
1702 // schedule a locate-roll to refill the diskstreams at the
1703 // previous loop end
1704 loop_changing = true;
1706 if (location->end() > last_loopend) {
1707 clear_events (SessionEvent::LocateRoll);
1708 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1714 clear_events (SessionEvent::AutoLoopDeclick);
1715 clear_events (SessionEvent::AutoLoop);
1718 /* possibly move playhead if not rolling; if we are rolling we'll move
1719 to the loop start on stop if that is appropriate.
1724 if (!transport_rolling() && select_playhead_priority_target (pos)) {
1725 if (pos == location->start()) {
1726 request_locate (pos);
1731 last_loopend = location->end();
1736 Session::set_auto_punch_location (Location* location)
1740 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1741 punch_connections.drop_connections();
1742 existing->set_auto_punch (false, this);
1743 remove_event (existing->start(), SessionEvent::PunchIn);
1744 clear_events (SessionEvent::PunchOut);
1745 auto_punch_location_changed (0);
1750 if (location == 0) {
1754 if (location->end() <= location->start()) {
1755 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1759 punch_connections.drop_connections ();
1761 location->StartChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, location));
1762 location->EndChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, location));
1763 location->Changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, location));
1765 location->set_auto_punch (true, this);
1767 auto_punch_changed (location);
1769 auto_punch_location_changed (location);
1773 Session::set_session_extents (framepos_t start, framepos_t end)
1776 if ((existing = _locations->session_range_location()) == 0) {
1777 //if there is no existing session, we need to make a new session location (should never happen)
1778 existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange, 0);
1782 error << _("Session: you can't use that location for session start/end)") << endmsg;
1786 existing->set( start, end );
1792 Session::set_auto_loop_location (Location* location)
1796 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1797 loop_connections.drop_connections ();
1798 existing->set_auto_loop (false, this);
1799 remove_event (existing->end(), SessionEvent::AutoLoop);
1802 auto_loop_declick_range (existing, dcp, dcl);
1803 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1804 auto_loop_location_changed (0);
1809 if (location == 0) {
1813 if (location->end() <= location->start()) {
1814 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1818 last_loopend = location->end();
1820 loop_connections.drop_connections ();
1822 location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1823 location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1824 location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1825 location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1827 location->set_auto_loop (true, this);
1829 if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
1830 // set all tracks to use internal looping
1831 boost::shared_ptr<RouteList> rl = routes.reader ();
1832 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1833 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1834 if (tr && !tr->hidden()) {
1835 tr->set_loop (location);
1840 /* take care of our stuff first */
1842 auto_loop_changed (location);
1844 /* now tell everyone else */
1846 auto_loop_location_changed (location);
1850 Session::update_marks (Location*)
1856 Session::update_skips (Location* loc, bool consolidate)
1858 if (_ignore_skips_updates) {
1862 Locations::LocationList skips;
1865 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1866 consolidate_skips (loc);
1869 sync_locations_to_skips ();
1875 Session::consolidate_skips (Location* loc)
1877 Locations::LocationList all_locations = _locations->list ();
1879 for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1881 if (!(*l)->is_skip ()) {
1886 /* don't test against self */
1893 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1894 case Evoral::OverlapInternal:
1895 case Evoral::OverlapExternal:
1896 case Evoral::OverlapStart:
1897 case Evoral::OverlapEnd:
1898 /* adjust new location to cover existing one */
1899 loc->set_start (min (loc->start(), (*l)->start()));
1900 loc->set_end (max (loc->end(), (*l)->end()));
1901 /* we don't need this one any more */
1902 _locations->remove (*l);
1903 /* the location has been deleted, so remove reference to it in our local list */
1904 l = all_locations.erase (l);
1907 case Evoral::OverlapNone:
1915 Session::sync_locations_to_skips ()
1917 /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1918 * Session::_sync_locations_to_skips() from the audioengine thread.
1920 clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1924 Session::_sync_locations_to_skips ()
1926 /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1928 Locations::LocationList const & locs (_locations->list());
1930 for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1932 Location* location = *i;
1934 if (location->is_skip() && location->is_skipping()) {
1935 SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1943 Session::location_added (Location *location)
1945 if (location->is_auto_punch()) {
1946 set_auto_punch_location (location);
1949 if (location->is_auto_loop()) {
1950 set_auto_loop_location (location);
1953 if (location->is_session_range()) {
1954 /* no need for any signal handling or event setting with the session range,
1955 because we keep a direct reference to it and use its start/end directly.
1957 _session_range_location = location;
1960 if (location->is_mark()) {
1961 /* listen for per-location signals that require us to do any * global updates for marks */
1963 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1964 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1965 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1966 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1967 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1970 if (location->is_range_marker()) {
1971 /* listen for per-location signals that require us to do any * global updates for marks */
1973 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1974 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1975 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1976 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1977 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1980 if (location->is_skip()) {
1981 /* listen for per-location signals that require us to update skip-locate events */
1983 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1984 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1985 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1986 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
1987 location->PositionLockStyleChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1989 update_skips (location, true);
1996 Session::location_removed (Location *location)
1998 if (location->is_auto_loop()) {
1999 set_auto_loop_location (0);
2000 set_track_loop (false);
2003 if (location->is_auto_punch()) {
2004 set_auto_punch_location (0);
2007 if (location->is_session_range()) {
2008 /* this is never supposed to happen */
2009 error << _("programming error: session range removed!") << endl;
2012 if (location->is_skip()) {
2014 update_skips (location, false);
2021 Session::locations_changed ()
2023 _locations->apply (*this, &Session::_locations_changed);
2027 Session::_locations_changed (const Locations::LocationList& locations)
2029 /* There was some mass-change in the Locations object.
2031 We might be re-adding a location here but it doesn't actually matter
2032 for all the locations that the Session takes an interest in.
2036 PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
2037 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
2038 location_added (*i);
2042 update_skips (NULL, false);
2046 Session::enable_record ()
2048 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
2049 /* no recording at anything except normal speed */
2054 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
2056 if (rs == Recording) {
2060 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
2062 _last_record_location = _transport_frame;
2063 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
2065 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2066 set_track_monitor_input_status (true);
2069 RecordStateChanged ();
2076 Session::set_all_tracks_record_enabled (bool enable )
2078 boost::shared_ptr<RouteList> rl = routes.reader();
2079 set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), enable, Controllable::NoGroup);
2083 Session::disable_record (bool rt_context, bool force)
2087 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
2089 if (!Config->get_latched_record_enable () || force) {
2090 g_atomic_int_set (&_record_status, Disabled);
2091 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
2093 if (rs == Recording) {
2094 g_atomic_int_set (&_record_status, Enabled);
2098 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2099 set_track_monitor_input_status (false);
2102 RecordStateChanged (); /* emit signal */
2105 remove_pending_capture_state ();
2107 unset_preroll_record_punch ();
2112 Session::step_back_from_record ()
2114 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
2116 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
2117 set_track_monitor_input_status (false);
2120 RecordStateChanged (); /* emit signal */
2125 Session::maybe_enable_record (bool rt_context)
2127 if (_step_editors > 0) {
2131 g_atomic_int_set (&_record_status, Enabled);
2133 /* This function is currently called from somewhere other than an RT thread.
2134 * (except maybe lua scripts, which can use rt_context = true)
2135 * This save_state() call therefore doesn't impact anything. Doing it here
2136 * means that we save pending state of which sources the next record will use,
2137 * which gives us some chance of recovering from a crash during the record.
2141 save_state ("", true);
2144 if (_transport_speed) {
2145 if (!config.get_punch_in() && !preroll_record_punch_enabled ()) {
2149 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
2150 RecordStateChanged (); /* EMIT SIGNAL */
2157 Session::audible_frame (bool* latent_locate) const
2161 frameoffset_t offset = worst_playback_latency (); // - _engine.samples_since_cycle_start ();
2162 offset *= transport_speed ();
2163 if (latent_locate) {
2164 *latent_locate = false;
2167 if (synced_to_engine()) {
2168 /* Note: this is basically just sync-to-JACK */
2169 ret = _engine.transport_frame();
2171 ret = _transport_frame;
2174 if (transport_rolling()) {
2177 /* Check to see if we have passed the first guaranteed
2178 * audible frame past our last start position. if not,
2179 * return that last start point because in terms
2180 * of audible frames, we have not moved yet.
2182 * `Start position' in this context means the time we last
2183 * either started, located, or changed transport direction.
2186 if (_transport_speed > 0.0f) {
2188 if (!play_loop || !have_looped) {
2189 if (ret < _last_roll_or_reversal_location) {
2190 if (latent_locate) {
2191 *latent_locate = true;
2193 return _last_roll_or_reversal_location;
2196 /* the play-position wrapped at the loop-point
2197 * ardour is already playing the beginning of the loop,
2198 * but due to playback latency, the "audible frame"
2199 * is still at the end of the loop.
2201 Location *location = _locations->auto_loop_location();
2202 frameoffset_t lo = location->start() - ret;
2204 ret = location->end () - lo;
2205 if (latent_locate) {
2206 *latent_locate = true;
2211 } else if (_transport_speed < 0.0f) {
2213 /* XXX wot? no backward looping? */
2215 if (ret > _last_roll_or_reversal_location) {
2216 return _last_roll_or_reversal_location;
2221 return std::max ((framepos_t)0, ret);
2226 Session::preroll_samples (framepos_t pos) const
2228 const float pr = Config->get_preroll_seconds();
2229 if (pos >= 0 && pr < 0) {
2230 const Tempo& tempo = _tempo_map->tempo_at_frame (pos);
2231 const Meter& meter = _tempo_map->meter_at_frame (pos);
2232 return meter.frames_per_bar (tempo, frame_rate()) * -pr;
2237 return pr * frame_rate();
2241 Session::set_frame_rate (framecnt_t frames_per_second)
2243 /** \fn void Session::set_frame_size(framecnt_t)
2244 the AudioEngine object that calls this guarantees
2245 that it will not be called while we are also in
2246 ::process(). Its fine to do things that block
2250 if (_base_frame_rate == 0) {
2251 _base_frame_rate = frames_per_second;
2253 else if (_base_frame_rate != frames_per_second && frames_per_second != _nominal_frame_rate) {
2254 NotifyAboutSampleRateMismatch (_base_frame_rate, frames_per_second);
2256 _nominal_frame_rate = frames_per_second;
2261 reset_write_sources (false);
2263 // XXX we need some equivalent to this, somehow
2264 // SndFileSource::setup_standard_crossfades (frames_per_second);
2268 /* XXX need to reset/reinstantiate all LADSPA plugins */
2272 Session::set_block_size (pframes_t nframes)
2274 /* the AudioEngine guarantees
2275 that it will not be called while we are also in
2276 ::process(). It is therefore fine to do things that block
2281 current_block_size = nframes;
2285 boost::shared_ptr<RouteList> r = routes.reader ();
2287 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2288 (*i)->set_block_size (nframes);
2291 boost::shared_ptr<RouteList> rl = routes.reader ();
2292 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2293 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2295 tr->set_block_size (nframes);
2299 set_worst_io_latencies ();
2305 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2307 boost::shared_ptr<Route> r2;
2309 if (r1->feeds (rbase) && rbase->feeds (r1)) {
2310 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2314 /* make a copy of the existing list of routes that feed r1 */
2316 Route::FedBy existing (r1->fed_by());
2318 /* for each route that feeds r1, recurse, marking it as feeding
2322 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2323 if (!(r2 = i->r.lock ())) {
2324 /* (*i) went away, ignore it */
2328 /* r2 is a route that feeds r1 which somehow feeds base. mark
2329 base as being fed by r2
2332 rbase->add_fed_by (r2, i->sends_only);
2336 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2340 if (r1->feeds (r2) && r2->feeds (r1)) {
2344 /* now recurse, so that we can mark base as being fed by
2345 all routes that feed r2
2348 trace_terminal (r2, rbase);
2355 Session::resort_routes ()
2357 /* don't do anything here with signals emitted
2358 by Routes during initial setup or while we
2359 are being destroyed.
2362 if (_state_of_the_state & (InitialConnecting | Deletion)) {
2366 if (_route_deletion_in_progress) {
2371 RCUWriter<RouteList> writer (routes);
2372 boost::shared_ptr<RouteList> r = writer.get_copy ();
2373 resort_routes_using (r);
2374 /* writer goes out of scope and forces update */
2378 if (DEBUG_ENABLED(DEBUG::Graph)) {
2379 boost::shared_ptr<RouteList> rl = routes.reader ();
2380 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2381 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2383 const Route::FedBy& fb ((*i)->fed_by());
2385 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2386 boost::shared_ptr<Route> sf = f->r.lock();
2388 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2397 /** This is called whenever we need to rebuild the graph of how we will process
2399 * @param r List of routes, in any order.
2403 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2405 /* We are going to build a directed graph of our routes;
2406 this is where the edges of that graph are put.
2411 /* Go through all routes doing two things:
2413 * 1. Collect the edges of the route graph. Each of these edges
2414 * is a pair of routes, one of which directly feeds the other
2415 * either by a JACK connection or by an internal send.
2417 * 2. Begin the process of making routes aware of which other
2418 * routes directly or indirectly feed them. This information
2419 * is used by the solo code.
2422 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2424 /* Clear out the route's list of direct or indirect feeds */
2425 (*i)->clear_fed_by ();
2427 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2429 bool via_sends_only;
2431 /* See if this *j feeds *i according to the current state of the JACK
2432 connections and internal sends.
2434 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2435 /* add the edge to the graph (part #1) */
2436 edges.add (*j, *i, via_sends_only);
2437 /* tell the route (for part #2) */
2438 (*i)->add_fed_by (*j, via_sends_only);
2443 /* Attempt a topological sort of the route graph */
2444 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2446 if (sorted_routes) {
2447 /* We got a satisfactory topological sort, so there is no feedback;
2450 Note: the process graph rechain does not require a
2451 topologically-sorted list, but hey ho.
2453 if (_process_graph) {
2454 _process_graph->rechain (sorted_routes, edges);
2457 _current_route_graph = edges;
2459 /* Complete the building of the routes' lists of what directly
2460 or indirectly feeds them.
2462 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2463 trace_terminal (*i, *i);
2466 *r = *sorted_routes;
2469 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2470 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2471 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
2475 SuccessfulGraphSort (); /* EMIT SIGNAL */
2478 /* The topological sort failed, so we have a problem. Tell everyone
2479 and stick to the old graph; this will continue to be processed, so
2480 until the feedback is fixed, what is played back will not quite
2481 reflect what is actually connected. Note also that we do not
2482 do trace_terminal here, as it would fail due to an endless recursion,
2483 so the solo code will think that everything is still connected
2487 FeedbackDetected (); /* EMIT SIGNAL */
2492 /** Find a route name starting with \a base, maybe followed by the
2493 * lowest \a id. \a id will always be added if \a definitely_add_number
2494 * is true on entry; otherwise it will only be added if required
2495 * to make the name unique.
2497 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2498 * The available route name with the lowest ID will be used, and \a id
2499 * will be set to the ID.
2501 * \return false if a route name could not be found, and \a track_name
2502 * and \a id do not reflect a free route name.
2505 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2507 /* the base may conflict with ports that do not belong to existing
2508 routes, but hidden objects like the click track. So check port names
2509 before anything else.
2512 for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2513 if (base == reserved->first) {
2514 /* Check if this reserved name already exists, and if
2515 so, disallow it without a numeric suffix.
2517 if (!reserved->second || route_by_name (reserved->first)) {
2518 definitely_add_number = true;
2527 /* if we have "base 1" already, it doesn't make sense to add "base"
2528 * if "base 1" has been deleted, adding "base" is no worse than "base 1"
2530 if (!definitely_add_number && route_by_name (base) == 0 && (route_by_name (string_compose("%1 1", base)) == 0)) {
2531 /* just use the base */
2537 name = string_compose ("%1 %2", base, id);
2539 if (route_by_name (name) == 0) {
2545 } while (id < (UINT_MAX-1));
2550 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2552 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2554 in = ChanCount::ZERO;
2555 out = ChanCount::ZERO;
2557 boost::shared_ptr<RouteList> r = routes.reader ();
2559 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2560 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2564 assert (!tr->is_auditioner()); // XXX remove me
2565 in += tr->n_inputs();
2566 out += tr->n_outputs();
2571 Session::default_track_name_pattern (DataType t)
2574 case DataType::AUDIO:
2575 if (Profile->get_trx()) {
2582 case DataType::MIDI:
2589 /** Caller must not hold process lock
2590 * @param name_template string to use for the start of the name, or "" to use "MIDI".
2591 * @param instrument plugin info for the instrument to insert pre-fader, if any
2593 list<boost::shared_ptr<MidiTrack> >
2594 Session::new_midi_track (const ChanCount& input, const ChanCount& output, bool strict_io,
2595 boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2596 RouteGroup* route_group, uint32_t how_many,
2597 string name_template, PresentationInfo::order_t order,
2601 uint32_t track_id = 0;
2603 RouteList new_routes;
2604 list<boost::shared_ptr<MidiTrack> > ret;
2606 const string name_pattern = default_track_name_pattern (DataType::MIDI);
2607 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2610 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2611 error << "cannot find name for new midi track" << endmsg;
2615 boost::shared_ptr<MidiTrack> track;
2618 track.reset (new MidiTrack (*this, track_name, mode));
2620 if (track->init ()) {
2625 track->set_strict_io (true);
2628 track->use_new_diskstream();
2630 BOOST_MARK_TRACK (track);
2633 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2634 if (track->input()->ensure_io (input, false, this)) {
2635 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2639 if (track->output()->ensure_io (output, false, this)) {
2640 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2645 track->non_realtime_input_change();
2648 route_group->add (track);
2651 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2653 new_routes.push_back (track);
2654 ret.push_back (track);
2657 catch (failed_constructor &err) {
2658 error << _("Session: could not create new midi track.") << endmsg;
2662 catch (AudioEngine::PortRegistrationFailure& pfe) {
2664 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;
2672 if (!new_routes.empty()) {
2673 StateProtector sp (this);
2674 if (Profile->get_trx()) {
2675 add_routes (new_routes, false, false, false, order);
2677 add_routes (new_routes, true, true, false, order);
2681 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2682 PluginPtr plugin = instrument->load (*this);
2684 warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2688 plugin->load_preset (*pset);
2690 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2692 pi->set_strict_io (true);
2695 (*r)->add_processor (pi, PreFader);
2697 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2698 (*r)->move_instrument_down (false);
2708 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, bool strict_io,
2709 boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2710 PresentationInfo::Flag flag, PresentationInfo::order_t order)
2713 uint32_t bus_id = 0;
2717 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2720 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2721 error << "cannot find name for new midi bus" << endmsg;
2726 boost::shared_ptr<Route> bus (new Route (*this, bus_name, flag, DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2733 bus->set_strict_io (true);
2736 BOOST_MARK_ROUTE(bus);
2739 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2741 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2742 error << _("cannot configure new midi bus input") << endmsg;
2747 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2748 error << _("cannot configure new midi bus output") << endmsg;
2754 route_group->add (bus);
2757 bus->add_internal_return ();
2758 ret.push_back (bus);
2761 catch (failed_constructor &err) {
2762 error << _("Session: could not create new audio route.") << endmsg;
2766 catch (AudioEngine::PortRegistrationFailure& pfe) {
2767 error << pfe.what() << endmsg;
2777 StateProtector sp (this);
2778 add_routes (ret, false, false, false, order);
2781 for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2782 PluginPtr plugin = instrument->load (*this);
2784 warning << "Failed to add Synth Plugin to newly created track." << endmsg;
2788 plugin->load_preset (*pset);
2790 boost::shared_ptr<PluginInsert> pi (new PluginInsert (*this, plugin));
2792 pi->set_strict_io (true);
2795 (*r)->add_processor (pi, PreFader);
2797 if (Profile->get_mixbus () && pi->configured () && pi->output_streams().n_audio() > 2) {
2798 (*r)->move_instrument_down (false);
2810 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2812 boost::shared_ptr<Route> midi_track (wmt.lock());
2818 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2820 if (change.after.n_audio() <= change.before.n_audio()) {
2824 /* new audio ports: make sure the audio goes somewhere useful,
2825 * unless the user has no-auto-connect selected.
2827 * The existing ChanCounts don't matter for this call as they are only
2828 * to do with matching input and output indices, and we are only changing
2831 auto_connect_route (midi_track, false, ChanCount(), change.before);
2835 #ifdef USE_TRACKS_CODE_FEATURES
2838 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2840 return route1->remote_control_id() < route2->remote_control_id();
2844 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2846 // it is not allowed to perform connection
2847 if (!IO::connecting_legal) {
2851 // if we are deleting routes we will call this once at the end
2852 if (_route_deletion_in_progress) {
2856 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2862 // We need to disconnect the route's inputs and outputs first
2863 // basing on autoconnect configuration
2864 bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2865 bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2867 ChanCount existing_inputs;
2868 ChanCount existing_outputs;
2869 count_existing_track_channels (existing_inputs, existing_outputs);
2871 //ChanCount inputs = ChanCount::ZERO;
2872 //ChanCount outputs = ChanCount::ZERO;
2874 RouteList existing_routes = *routes.reader ();
2875 existing_routes.sort (compare_routes_by_remote_id);
2878 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2880 vector<string> physinputs;
2881 vector<string> physoutputs;
2883 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2884 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2886 uint32_t input_n = 0;
2887 uint32_t output_n = 0;
2888 RouteList::iterator rIter = existing_routes.begin();
2889 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2890 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2891 for (; rIter != existing_routes.end(); ++rIter) {
2892 if (*rIter == _master_out || *rIter == _monitor_out ) {
2896 if (current_output_auto_connection == AutoConnectPhysical) {
2897 (*rIter)->amp()->deactivate();
2898 } else if (current_output_auto_connection == AutoConnectMaster) {
2899 (*rIter)->amp()->activate();
2902 if (reconnectIputs) {
2903 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2905 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2907 if (current_input_auto_connection & AutoConnectPhysical) {
2909 if ( input_n == physinputs.size() ) {
2913 string port = physinputs[input_n];
2915 if (port.empty() ) {
2916 error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2919 //GZ: check this; could be heavy
2920 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2926 if (reconnectOutputs) {
2928 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2929 if (current_output_auto_connection & AutoConnectPhysical) {
2931 //GZ: check this; could be heavy
2932 (*rIter)->output()->disconnect (this);
2933 size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2935 //GZ: check this; could be heavy
2936 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2938 } else if (current_output_auto_connection & AutoConnectMaster){
2940 if (!reconnect_master) {
2944 //GZ: check this; could be heavy
2945 (*rIter)->output()->disconnect (this);
2948 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2949 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2951 error << error << "Master bus is not available" << endmsg;
2956 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2957 if (current_output_auto_connection & AutoConnectPhysical) {
2959 if ( output_n == physoutputs.size() ) {
2963 string port = physoutputs[output_n];
2965 if (port.empty() ) {
2966 error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2969 //GZ: check this; could be heavy
2970 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2973 } else if (current_output_auto_connection & AutoConnectMaster) {
2975 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2979 // connect to master bus
2980 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2982 if (port.empty() ) {
2983 error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2987 //GZ: check this; could be heavy
2988 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2995 _master_out->output()->disconnect (this);
2996 auto_connect_master_bus ();
3001 session_routes_reconnected (); /* EMIT SIGNAL */
3005 Session::reconnect_midi_scene_ports(bool inputs)
3009 boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
3011 scene_in_ptr->disconnect_all ();
3013 std::vector<EngineStateController::MidiPortState> midi_port_states;
3014 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
3016 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3018 for (; state_iter != midi_port_states.end(); ++state_iter) {
3019 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
3020 scene_in_ptr->connect (state_iter->name);
3027 boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
3029 if (scene_out_ptr ) {
3030 scene_out_ptr->disconnect_all ();
3032 std::vector<EngineStateController::MidiPortState> midi_port_states;
3033 EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
3035 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3037 for (; state_iter != midi_port_states.end(); ++state_iter) {
3038 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
3039 scene_out_ptr->connect (state_iter->name);
3047 Session::reconnect_mtc_ports ()
3049 boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
3055 mtc_in_ptr->disconnect_all ();
3057 std::vector<EngineStateController::MidiPortState> midi_port_states;
3058 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
3060 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
3062 for (; state_iter != midi_port_states.end(); ++state_iter) {
3063 if (state_iter->available && state_iter->mtc_in) {
3064 mtc_in_ptr->connect (state_iter->name);
3068 if (!_midi_ports->mtc_input_port ()->connected () &&
3069 config.get_external_sync () &&
3070 (Config->get_sync_source () == MTC) ) {
3071 config.set_external_sync (false);
3074 if ( ARDOUR::Profile->get_trx () ) {
3075 // Tracks need this signal to update timecode_source_dropdown
3076 MtcOrLtcInputPortChanged (); //emit signal
3081 Session::reconnect_mmc_ports(bool inputs)
3083 if (inputs ) { // get all enabled midi input ports
3085 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
3087 mmc_in_ptr->disconnect_all ();
3088 std::vector<std::string> enabled_midi_inputs;
3089 EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
3091 std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
3093 for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
3094 mmc_in_ptr->connect (*port_iter);
3098 } else { // get all enabled midi output ports
3100 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
3102 mmc_out_ptr->disconnect_all ();
3103 std::vector<std::string> enabled_midi_outputs;
3104 EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
3106 std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
3108 for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
3109 mmc_out_ptr->connect (*port_iter);
3118 Session::ensure_stripable_sort_order ()
3121 get_stripables (sl);
3122 sl.sort (Stripable::Sorter ());
3124 bool change = false;
3125 PresentationInfo::order_t order = 0;
3127 for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3128 boost::shared_ptr<Stripable> s (*si);
3129 assert (!s->is_auditioner ()); // XXX remove me
3130 if (s->is_monitor ()) {
3133 if (order != s->presentation_info().order()) {
3134 s->set_presentation_order (order);
3143 Session::ensure_route_presentation_info_gap (PresentationInfo::order_t first_new_order, uint32_t how_many)
3145 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("ensure order gap starting at %1 for %2\n", first_new_order, how_many));
3147 if (first_new_order == PresentationInfo::max_order) {
3148 /* adding at end, no worries */
3152 /* create a gap in the presentation info to accomodate @param how_many
3156 get_stripables (sl);
3158 for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
3159 boost::shared_ptr<Stripable> s (*si);
3161 if (s->presentation_info().special (false)) {
3165 if (!s->presentation_info().order_set()) {
3169 if (s->presentation_info().order () >= first_new_order) {
3170 s->set_presentation_order (s->presentation_info().order () + how_many);
3175 /** Caller must not hold process lock
3176 * @param name_template string to use for the start of the name, or "" to use "Audio".
3178 list< boost::shared_ptr<AudioTrack> >
3179 Session::new_audio_track (int input_channels, int output_channels, RouteGroup* route_group,
3180 uint32_t how_many, string name_template, PresentationInfo::order_t order,
3184 uint32_t track_id = 0;
3186 RouteList new_routes;
3187 list<boost::shared_ptr<AudioTrack> > ret;
3189 const string name_pattern = default_track_name_pattern (DataType::AUDIO);
3190 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
3194 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
3195 error << "cannot find name for new audio track" << endmsg;
3199 boost::shared_ptr<AudioTrack> track;
3202 track.reset (new AudioTrack (*this, track_name, mode));
3204 if (track->init ()) {
3208 if (Profile->get_mixbus ()) {
3209 track->set_strict_io (true);
3212 if (ARDOUR::Profile->get_trx ()) {
3213 // TRACKS considers it's not a USE CASE, it's
3214 // a piece of behavior of the session model:
3216 // Gain for a newly created route depends on
3217 // the current output_auto_connect mode:
3219 // 0 for Stereo Out mode
3221 if (Config->get_output_auto_connect() & AutoConnectMaster) {
3222 track->gain_control()->set_value (dB_to_coefficient (0), Controllable::NoGroup);
3226 track->use_new_diskstream();
3228 BOOST_MARK_TRACK (track);
3231 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3233 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3234 error << string_compose (
3235 _("cannot configure %1 in/%2 out configuration for new audio track"),
3236 input_channels, output_channels)
3241 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3242 error << string_compose (
3243 _("cannot configure %1 in/%2 out configuration for new audio track"),
3244 input_channels, output_channels)
3251 route_group->add (track);
3254 track->non_realtime_input_change();
3256 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
3258 new_routes.push_back (track);
3259 ret.push_back (track);
3262 catch (failed_constructor &err) {
3263 error << _("Session: could not create new audio track.") << endmsg;
3267 catch (AudioEngine::PortRegistrationFailure& pfe) {
3269 error << pfe.what() << endmsg;
3277 if (!new_routes.empty()) {
3278 StateProtector sp (this);
3279 if (Profile->get_trx()) {
3280 add_routes (new_routes, false, false, false, order);
3282 add_routes (new_routes, true, true, false, order);
3289 /** Caller must not hold process lock.
3290 * @param name_template string to use for the start of the name, or "" to use "Bus".
3293 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template,
3294 PresentationInfo::Flag flags, PresentationInfo::order_t order)
3297 uint32_t bus_id = 0;
3301 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3304 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3305 error << "cannot find name for new audio bus" << endmsg;
3310 boost::shared_ptr<Route> bus (new Route (*this, bus_name, flags, DataType::AUDIO));
3316 if (Profile->get_mixbus ()) {
3317 bus->set_strict_io (true);
3320 BOOST_MARK_ROUTE(bus);
3323 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3325 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3326 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3327 input_channels, output_channels)
3333 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3334 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3335 input_channels, output_channels)
3342 route_group->add (bus);
3345 bus->add_internal_return ();
3346 ret.push_back (bus);
3349 catch (failed_constructor &err) {
3350 error << _("Session: could not create new audio route.") << endmsg;
3354 catch (AudioEngine::PortRegistrationFailure& pfe) {
3355 error << pfe.what() << endmsg;
3365 StateProtector sp (this);
3366 if (Profile->get_trx()) {
3367 add_routes (ret, false, false, false, order);
3369 add_routes (ret, false, true, true, order); // autoconnect // outputs only
3378 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
3379 PlaylistDisposition pd)
3383 if (!tree.read (template_path.c_str())) {
3387 return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
3391 Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3394 uint32_t number = 0;
3395 const uint32_t being_added = how_many;
3396 /* This will prevent the use of any existing XML-provided PBD::ID
3399 Stateful::ForceIDRegeneration force_ids;
3400 IO::disable_connecting ();
3404 /* We're going to modify the node contents a bit so take a
3405 * copy. The node may be re-used when duplicating more than once.
3408 XMLNode node_copy (node);
3413 if (!name_base.empty()) {
3415 /* if we're adding more than one routes, force
3416 * all the names of the new routes to be
3417 * numbered, via the final parameter.
3420 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3421 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3427 string const route_name = node_copy.property(X_("name"))->value ();
3429 /* generate a new name by adding a number to the end of the template name */
3430 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3431 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3432 abort(); /*NOTREACHED*/
3436 /* set this name in the XML description that we are about to use */
3438 if (pd == CopyPlaylist) {
3439 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3441 const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3442 boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3443 // Use same name as Route::set_name_in_state so playlist copy
3444 // is picked up when creating the Route in XMLRouteFactory below
3445 playlist = PlaylistFactory::create (playlist, string_compose ("%1.1", name));
3446 playlist->reset_shares ();
3448 } else if (pd == SharePlaylist) {
3449 XMLNode* ds_node = find_named_node (node_copy, "Diskstream");
3451 const std::string playlist_name = ds_node->property (X_("playlist"))->value ();
3452 boost::shared_ptr<Playlist> playlist = playlists->by_name (playlist_name);
3453 playlist->share_with ((node_copy.property (X_("id")))->value());
3457 bool rename_playlist = (pd == CopyPlaylist || pd == NewPlaylist);
3459 Route::set_name_in_state (node_copy, name, rename_playlist);
3461 /* trim bitslots from listen sends so that new ones are used */
3462 XMLNodeList children = node_copy.children ();
3463 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3464 if ((*i)->name() == X_("Processor")) {
3465 /* ForceIDRegeneration does not catch the following */
3466 XMLProperty const * role = (*i)->property (X_("role"));
3467 XMLProperty const * type = (*i)->property (X_("type"));
3468 if (role && role->value() == X_("Aux")) {
3469 /* check if the target bus exists.
3470 * we should not save aux-sends in templates.
3472 XMLProperty const * target = (*i)->property (X_("target"));
3474 (*i)->set_property ("type", "dangling-aux-send");
3477 boost::shared_ptr<Route> r = route_by_id (target->value());
3478 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3479 (*i)->set_property ("type", "dangling-aux-send");
3483 if (role && role->value() == X_("Listen")) {
3484 (*i)->remove_property (X_("bitslot"));
3486 else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3487 Delivery::Role xrole;
3488 uint32_t bitslot = 0;
3489 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3490 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3491 (*i)->remove_property (X_("bitslot"));
3492 (*i)->remove_property (X_("name"));
3493 (*i)->set_property ("bitslot", bitslot);
3494 (*i)->set_property ("name", name);
3496 else if (type && type->value() == X_("intreturn")) {
3497 (*i)->remove_property (X_("bitslot"));
3498 (*i)->set_property ("ignore-bitslot", "1");
3500 else if (type && type->value() == X_("return")) {
3501 // Return::set_state() generates a new one
3502 (*i)->remove_property (X_("bitslot"));
3504 else if (type && type->value() == X_("port")) {
3505 // PortInsert::set_state() handles the bitslot
3506 (*i)->remove_property (X_("bitslot"));
3507 (*i)->set_property ("ignore-name", "1");
3512 /* new routes start off unsoloed to avoid issues related to
3513 upstream / downstream buses. */
3514 node_copy.remove_node_and_delete (X_("Controllable"), X_("name"), X_("solo"));
3516 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3519 error << _("Session: cannot create track/bus from template description") << endmsg;
3523 if (boost::dynamic_pointer_cast<Track>(route)) {
3524 /* force input/output change signals so that the new diskstream
3525 picks up the configuration of the route. During session
3526 loading this normally happens in a different way.
3529 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3531 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3532 change.after = route->input()->n_ports();
3533 route->input()->changed (change, this);
3534 change.after = route->output()->n_ports();
3535 route->output()->changed (change, this);
3538 ret.push_back (route);
3541 catch (failed_constructor &err) {
3542 error << _("Session: could not create new route from template") << endmsg;
3546 catch (AudioEngine::PortRegistrationFailure& pfe) {
3547 error << pfe.what() << endmsg;
3556 StateProtector sp (this);
3557 if (Profile->get_trx()) {
3558 add_routes (ret, false, false, false, insert_at);
3560 add_routes (ret, true, true, false, insert_at);
3562 IO::enable_connecting ();
3569 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3572 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3573 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3576 error << _("Adding new tracks/busses failed") << endmsg;
3581 update_latency (true);
3582 update_latency (false);
3587 save_state (_current_snapshot_name);
3590 update_route_record_state ();
3592 RouteAdded (new_routes); /* EMIT SIGNAL */
3596 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3598 ChanCount existing_inputs;
3599 ChanCount existing_outputs;
3603 count_existing_track_channels (existing_inputs, existing_outputs);
3606 RCUWriter<RouteList> writer (routes);
3607 boost::shared_ptr<RouteList> r = writer.get_copy ();
3608 n_routes = r->size();
3609 r->insert (r->end(), new_routes.begin(), new_routes.end());
3611 /* if there is no control out and we're not in the middle of loading,
3612 * resort the graph here. if there is a control out, we will resort
3613 * toward the end of this method. if we are in the middle of loading,
3614 * we will resort when done.
3617 if (!_monitor_out && IO::connecting_legal) {
3618 resort_routes_using (r);
3622 /* monitor is not part of the order */
3624 assert (n_routes > 0);
3629 PresentationInfo::ChangeSuspender cs;
3630 ensure_route_presentation_info_gap (order, new_routes.size());
3632 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3634 boost::weak_ptr<Route> wpr (*x);
3635 boost::shared_ptr<Route> r (*x);
3637 r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3638 r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3639 r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3641 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3642 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3643 r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3645 if (r->is_master()) {
3649 if (r->is_monitor()) {
3653 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3655 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3656 track_playlist_changed (boost::weak_ptr<Track> (tr));
3657 tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3659 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3661 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3662 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3663 mt->presentation_info().PropertyChanged.connect_same_thread (*this, boost::bind (&Session::midi_track_presentation_info_changed, this, _1, boost::weak_ptr<MidiTrack>(mt)));
3667 if (!r->presentation_info().special (false)) {
3669 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3671 /* presentation info order may already have been set from XML */
3673 if (!r->presentation_info().order_set()) {
3674 if (order == PresentationInfo::max_order) {
3675 /* just add to the end */
3676 r->set_presentation_order (n_routes + added);
3677 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3679 r->set_presentation_order (order + added);
3680 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3683 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3687 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3688 /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3689 * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3691 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3693 r->presentation_info().order(),
3694 enum_2_string (r->presentation_info().flags()),
3695 r->presentation_info()));
3699 if (input_auto_connect || output_auto_connect) {
3700 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3701 existing_inputs += r->n_inputs();
3702 existing_outputs += r->n_outputs();
3707 ensure_stripable_sort_order ();
3710 if (_monitor_out && IO::connecting_legal) {
3711 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3713 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3714 if ((*x)->is_monitor()) {
3716 } else if ((*x)->is_master()) {
3719 (*x)->enable_monitor_send ();
3724 reassign_track_numbers ();
3728 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3730 boost::shared_ptr<RouteList> r = routes.reader ();
3731 boost::shared_ptr<Send> s;
3733 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3734 if ((s = (*i)->internal_send_for (dest)) != 0) {
3735 s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3741 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3743 boost::shared_ptr<RouteList> r = routes.reader ();
3744 boost::shared_ptr<Send> s;
3746 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3747 if ((s = (*i)->internal_send_for (dest)) != 0) {
3748 s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3754 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3756 boost::shared_ptr<RouteList> r = routes.reader ();
3757 boost::shared_ptr<Send> s;
3759 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3760 if ((s = (*i)->internal_send_for (dest)) != 0) {
3761 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3766 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3768 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3770 boost::shared_ptr<RouteList> r = routes.reader ();
3771 boost::shared_ptr<RouteList> t (new RouteList);
3773 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3774 /* no MIDI sends because there are no MIDI busses yet */
3775 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3780 add_internal_sends (dest, p, t);
3784 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3786 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3787 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3792 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3794 add_internal_send (dest, sender->before_processor_for_index (index), sender);
3798 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3800 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3804 if (!dest->internal_return()) {
3805 dest->add_internal_return ();
3808 sender->add_aux_send (dest, before);
3814 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3816 bool mute_changed = false;
3817 bool send_selected = false;
3819 { // RCU Writer scope
3820 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3821 RCUWriter<RouteList> writer (routes);
3822 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3824 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3826 if (_selection->selected (*iter)) {
3827 send_selected = true;
3830 if (*iter == _master_out) {
3834 /* speed up session deletion, don't do the solo dance */
3835 if (0 == (_state_of_the_state & Deletion)) {
3836 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3839 if ((*iter)->mute_control()->muted ()) {
3840 mute_changed = true;
3845 /* deleting the master out seems like a dumb
3846 idea, but its more of a UI policy issue
3850 if (*iter == _master_out) {
3851 _master_out = boost::shared_ptr<Route> ();
3854 if (*iter == _monitor_out) {
3855 _monitor_out.reset ();
3858 // We need to disconnect the route's inputs and outputs
3860 (*iter)->input()->disconnect (0);
3861 (*iter)->output()->disconnect (0);
3863 /* if the route had internal sends sending to it, remove them */
3864 if ((*iter)->internal_return()) {
3866 boost::shared_ptr<RouteList> r = routes.reader ();
3867 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3868 boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3870 (*i)->remove_processor (s);
3875 /* if the monitoring section had a pointer to this route, remove it */
3876 if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3877 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3878 ProcessorChangeBlocker pcb (this, false);
3879 (*iter)->remove_aux_or_listen (_monitor_out);
3882 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3883 if (mt && mt->step_editing()) {
3884 if (_step_editors > 0) {
3890 /* writer goes out of scope, forces route list update */
3892 } // end of RCU Writer scope
3895 MuteChanged (); /* EMIT SIGNAL */
3898 update_route_solo_state ();
3899 update_latency_compensation ();
3902 /* Re-sort routes to remove the graph's current references to the one that is
3903 * going away, then flush old references out of the graph.
3904 * Wave Tracks: reconnect routes
3907 #ifdef USE_TRACKS_CODE_FEATURES
3908 reconnect_existing_routes(true, false);
3910 routes.flush (); // maybe unsafe, see below.
3914 if (_process_graph && !(_state_of_the_state & Deletion)) {
3915 _process_graph->clear_other_chain ();
3918 /* get rid of it from the dead wood collection in the route list manager */
3919 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3923 /* remove these routes from the selection if appropriate, and signal
3924 * the change *before* we call DropReferences for them.
3927 if (send_selected && !deletion_in_progress()) {
3928 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3929 _selection->remove_stripable_by_id ((*iter)->id());
3932 pc.add (Properties::selected);
3933 PresentationInfo::Change (pc);
3936 /* try to cause everyone to drop their references
3937 * and unregister ports from the backend
3940 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3941 (*iter)->drop_references ();
3944 if (deletion_in_progress()) {
3949 pc.add (Properties::order);
3950 PresentationInfo::Change (pc);
3952 /* save the new state of the world */
3954 if (save_state (_current_snapshot_name)) {
3955 save_history (_current_snapshot_name);
3958 update_route_record_state ();
3962 Session::remove_route (boost::shared_ptr<Route> route)
3964 boost::shared_ptr<RouteList> rl (new RouteList);
3965 rl->push_back (route);
3970 Session::route_mute_changed ()
3972 MuteChanged (); /* EMIT SIGNAL */
3977 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3979 boost::shared_ptr<Route> route (wpr.lock());
3985 assert (Config->get_solo_control_is_listen_control());
3987 if (route->solo_control()->soloed_by_self_or_masters()) {
3989 if (Config->get_exclusive_solo()) {
3991 RouteGroup* rg = route->route_group ();
3992 const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3994 boost::shared_ptr<RouteList> r = routes.reader ();
3996 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3997 if ((*i) == route) {
3998 /* already changed */
4002 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4003 /* route does not get solo propagated to it */
4007 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4008 /* this route is a part of the same solo group as the route
4009 * that was changed. Changing that route did change or will
4010 * change all group members appropriately, so we can ignore it
4015 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
4021 } else if (_listen_cnt > 0) {
4028 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
4030 boost::shared_ptr<Route> route (wpr.lock());
4036 bool send_changed = false;
4038 if (route->solo_isolate_control()->solo_isolated()) {
4039 if (_solo_isolated_cnt == 0) {
4040 send_changed = true;
4042 _solo_isolated_cnt++;
4043 } else if (_solo_isolated_cnt > 0) {
4044 _solo_isolated_cnt--;
4045 if (_solo_isolated_cnt == 0) {
4046 send_changed = true;
4051 IsolatedChanged (); /* EMIT SIGNAL */
4056 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
4058 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1, update\n", self_solo_changed));
4060 boost::shared_ptr<Route> route (wpr.lock());
4066 if (Config->get_solo_control_is_listen_control()) {
4067 route_listen_changed (group_override, wpr);
4071 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()));
4073 if (route->solo_control()->transitioned_into_solo() == 0) {
4074 /* route solo changed by upstream/downstream or clear all solo state; not interesting
4077 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()));
4081 boost::shared_ptr<RouteList> r = routes.reader ();
4082 int32_t delta = route->solo_control()->transitioned_into_solo ();
4084 /* the route may be a member of a group that has shared-solo
4085 * semantics. If so, then all members of that group should follow the
4086 * solo of the changed route. But ... this is optional, controlled by a
4087 * Controllable::GroupControlDisposition.
4089 * The first argument to the signal that this method is connected to is the
4090 * GroupControlDisposition value that was used to change solo.
4092 * If the solo change was done with group semantics (either InverseGroup
4093 * (force the entire group to change even if the group shared solo is
4094 * disabled) or UseGroup (use the group, which may or may not have the
4095 * shared solo property enabled)) then as we propagate the change to
4096 * the entire session we should IGNORE THE GROUP that the changed route
4100 RouteGroup* rg = route->route_group ();
4101 const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
4103 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate to session, group accounted for ? %1\n", group_already_accounted_for));
4105 if (delta == 1 && Config->get_exclusive_solo()) {
4107 /* new solo: disable all other solos, but not the group if its solo-enabled */
4109 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4111 if ((*i) == route) {
4112 /* already changed */
4116 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4117 /* route does not get solo propagated to it */
4121 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4122 /* this route is a part of the same solo group as the route
4123 * that was changed. Changing that route did change or will
4124 * change all group members appropriately, so we can ignore it
4130 (*i)->solo_control()->set_value (0.0, group_override);
4134 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
4136 RouteList uninvolved;
4138 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
4140 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4141 bool via_sends_only;
4142 bool in_signal_flow;
4144 if ((*i) == route) {
4145 /* already changed */
4149 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
4150 /* route does not get solo propagated to it */
4151 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(),
4156 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
4157 /* this route is a part of the same solo group as the route
4158 * that was changed. Changing that route did change or will
4159 * change all group members appropriately, so we can ignore it
4165 in_signal_flow = false;
4167 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
4169 if ((*i)->feeds (route, &via_sends_only)) {
4170 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
4171 if (!via_sends_only) {
4172 if (!route->soloed_by_others_upstream()) {
4173 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
4175 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
4178 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
4180 in_signal_flow = true;
4182 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
4185 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
4187 if (route->feeds (*i, &via_sends_only)) {
4188 /* propagate solo upstream only if routing other than
4189 sends is involved, but do consider the other route
4190 (*i) to be part of the signal flow even if only
4193 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
4197 route->soloed_by_others_downstream(),
4198 route->soloed_by_others_upstream()));
4199 if (!via_sends_only) {
4200 //NB. Triggers Invert Push, which handles soloed by downstream
4201 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
4202 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
4204 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
4206 in_signal_flow = true;
4208 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
4211 if (!in_signal_flow) {
4212 uninvolved.push_back (*i);
4216 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
4218 /* now notify that the mute state of the routes not involved in the signal
4219 pathway of the just-solo-changed route may have altered.
4222 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
4223 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
4224 (*i)->act_on_mute ();
4225 /* Session will emit SoloChanged() after all solo changes are
4226 * complete, which should be used by UIs to update mute status
4232 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
4234 /* now figure out if anything that matters is soloed (or is "listening")*/
4236 bool something_soloed = false;
4237 bool something_listening = false;
4238 uint32_t listeners = 0;
4239 uint32_t isolated = 0;
4242 r = routes.reader();
4245 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4246 if ((*i)->can_solo()) {
4247 if (Config->get_solo_control_is_listen_control()) {
4248 if ((*i)->solo_control()->soloed_by_self_or_masters()) {
4250 something_listening = true;
4253 (*i)->set_listen (false);
4254 if ((*i)->can_solo() && (*i)->solo_control()->soloed_by_self_or_masters()) {
4255 something_soloed = true;
4260 if ((*i)->solo_isolate_control()->solo_isolated()) {
4265 if (something_soloed != _non_soloed_outs_muted) {
4266 _non_soloed_outs_muted = something_soloed;
4267 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4270 if (something_listening != _listening) {
4271 _listening = something_listening;
4272 SoloActive (_listening);
4275 _listen_cnt = listeners;
4277 if (isolated != _solo_isolated_cnt) {
4278 _solo_isolated_cnt = isolated;
4279 IsolatedChanged (); /* EMIT SIGNAL */
4282 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4283 something_soloed, listeners, isolated));
4286 SoloChanged (); /* EMIT SIGNAL */
4291 Session::muted () const
4293 // TODO consider caching the value on every MuteChanged signal,
4294 // Note that API users may also subscribe to MuteChanged and hence
4295 // this method needs to be called first.
4298 get_stripables (all);
4299 for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4300 assert (!(*i)->is_auditioner()); // XXX remove me
4301 if ((*i)->is_monitor()) {
4304 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route>(*i);
4305 if (r && !r->active()) {
4308 boost::shared_ptr<MuteControl> mc = (*i)->mute_control();
4309 if (mc && mc->muted ()) {
4317 std::vector<boost::weak_ptr<AutomationControl> >
4318 Session::cancel_all_mute ()
4321 get_stripables (all);
4322 std::vector<boost::weak_ptr<AutomationControl> > muted;
4323 boost::shared_ptr<ControlList> cl (new ControlList);
4324 for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
4325 assert (!(*i)->is_auditioner());
4326 if ((*i)->is_monitor()) {
4329 boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (*i);
4330 if (r && !r->active()) {
4333 boost::shared_ptr<AutomationControl> ac = (*i)->mute_control();
4334 if (ac && ac->get_value () > 0) {
4336 muted.push_back (boost::weak_ptr<AutomationControl>(ac));
4339 if (!cl->empty ()) {
4340 set_controls (cl, 0.0, PBD::Controllable::UseGroup);
4346 Session::get_stripables (StripableList& sl) const
4348 boost::shared_ptr<RouteList> r = routes.reader ();
4349 sl.insert (sl.end(), r->begin(), r->end());
4351 VCAList v = _vca_manager->vcas ();
4352 sl.insert (sl.end(), v.begin(), v.end());
4356 Session::get_stripables () const
4359 Session::get_stripables (rv);
4360 rv.sort (Stripable::Sorter ());
4364 boost::shared_ptr<RouteList>
4365 Session::get_routes_with_internal_returns() const
4367 boost::shared_ptr<RouteList> r = routes.reader ();
4368 boost::shared_ptr<RouteList> rl (new RouteList);
4370 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4371 if ((*i)->internal_return ()) {
4379 Session::io_name_is_legal (const std::string& name) const
4381 boost::shared_ptr<RouteList> r = routes.reader ();
4383 for (map<string,bool>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4384 if (name == reserved->first) {
4385 if (!route_by_name (reserved->first)) {
4386 /* first instance of a reserved name is allowed for some */
4387 return reserved->second;
4389 /* all other instances of a reserved name are not allowed */
4394 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4395 if ((*i)->name() == name) {
4399 if ((*i)->has_io_processor_named (name)) {
4408 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4411 vector<string> connections;
4413 /* if we are passed only a single route and we're not told to turn
4414 * others off, then just do the simple thing.
4417 if (flip_others == false && rl->size() == 1) {
4418 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4420 mt->set_input_active (onoff);
4425 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4427 PortSet& ps ((*rt)->input()->ports());
4429 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4430 p->get_connections (connections);
4433 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4434 routes_using_input_from (*s, rl2);
4437 /* scan all relevant routes to see if others are on or off */
4439 bool others_are_already_on = false;
4441 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4443 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4449 if ((*r) != (*rt)) {
4450 if (mt->input_active()) {
4451 others_are_already_on = true;
4454 /* this one needs changing */
4455 mt->set_input_active (onoff);
4461 /* globally reverse other routes */
4463 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4464 if ((*r) != (*rt)) {
4465 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4467 mt->set_input_active (!others_are_already_on);
4476 Session::routes_using_input_from (const string& str, RouteList& rl)
4478 boost::shared_ptr<RouteList> r = routes.reader();
4480 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4481 if ((*i)->input()->connected_to (str)) {
4487 boost::shared_ptr<Route>
4488 Session::route_by_name (string name) const
4490 boost::shared_ptr<RouteList> r = routes.reader ();
4492 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4493 if ((*i)->name() == name) {
4498 return boost::shared_ptr<Route> ((Route*) 0);
4501 boost::shared_ptr<Route>
4502 Session::route_by_id (PBD::ID id) const
4504 boost::shared_ptr<RouteList> r = routes.reader ();
4506 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4507 if ((*i)->id() == id) {
4512 return boost::shared_ptr<Route> ((Route*) 0);
4516 boost::shared_ptr<Stripable>
4517 Session::stripable_by_id (PBD::ID id) const
4520 get_stripables (sl);
4522 for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4523 if ((*s)->id() == id) {
4528 return boost::shared_ptr<Stripable>();
4531 boost::shared_ptr<Processor>
4532 Session::processor_by_id (PBD::ID id) const
4534 boost::shared_ptr<RouteList> r = routes.reader ();
4536 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4537 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4543 return boost::shared_ptr<Processor> ();
4546 boost::shared_ptr<Track>
4547 Session::track_by_diskstream_id (PBD::ID id) const
4549 boost::shared_ptr<RouteList> r = routes.reader ();
4551 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4552 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4553 if (t && t->using_diskstream_id (id)) {
4558 return boost::shared_ptr<Track> ();
4561 boost::shared_ptr<Route>
4562 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4564 return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4567 boost::shared_ptr<Stripable>
4568 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4571 PresentationInfo::order_t match_cnt = 0;
4573 get_stripables (sl);
4574 sl.sort (Stripable::Sorter());
4576 for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4578 if ((*s)->presentation_info().hidden()) {
4579 /* if the caller didn't explicitly ask for hidden
4580 stripables, ignore hidden ones. This matches
4581 the semantics of the pre-PresentationOrder
4582 "get by RID" logic of Ardour 4.x and earlier.
4584 XXX at some point we should likely reverse
4585 the logic of the flags, because asking for "the
4586 hidden stripables" is not going to be common,
4587 whereas asking for visible ones is normal.
4590 if (! (flags & PresentationInfo::Hidden)) {
4595 if ((*s)->presentation_info().flag_match (flags)) {
4596 if (match_cnt++ == n) {
4602 /* there is no nth stripable that matches the given flags */
4603 return boost::shared_ptr<Stripable>();
4606 boost::shared_ptr<Route>
4607 Session::route_by_selected_count (uint32_t id) const
4609 RouteList r (*(routes.reader ()));
4610 r.sort (Stripable::Sorter());
4612 RouteList::iterator i;
4614 for (i = r.begin(); i != r.end(); ++i) {
4615 if ((*i)->is_selected()) {
4623 return boost::shared_ptr<Route> ();
4627 Session::reassign_track_numbers ()
4631 RouteList r (*(routes.reader ()));
4632 r.sort (Stripable::Sorter());
4634 StateProtector sp (this);
4636 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4637 assert (!(*i)->is_auditioner());
4638 if (boost::dynamic_pointer_cast<Track> (*i)) {
4639 (*i)->set_track_number(++tn);
4641 else if (!(*i)->is_master() && !(*i)->is_monitor()) {
4642 (*i)->set_track_number(--bn);
4645 const uint32_t decimals = ceilf (log10f (tn + 1));
4646 const bool decimals_changed = _track_number_decimals != decimals;
4647 _track_number_decimals = decimals;
4649 if (decimals_changed && config.get_track_name_number ()) {
4650 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4651 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4653 t->resync_track_name();
4656 // trigger GUI re-layout
4657 config.ParameterChanged("track-name-number");
4661 if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4662 boost::shared_ptr<RouteList> rl = routes.reader ();
4663 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4664 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4672 Session::playlist_region_added (boost::weak_ptr<Region> w)
4674 boost::shared_ptr<Region> r = w.lock ();
4679 /* These are the operations that are currently in progress... */
4680 list<GQuark> curr = _current_trans_quarks;
4683 /* ...and these are the operations during which we want to update
4684 the session range location markers.
4687 ops.push_back (Operations::capture);
4688 ops.push_back (Operations::paste);
4689 ops.push_back (Operations::duplicate_region);
4690 ops.push_back (Operations::insert_file);
4691 ops.push_back (Operations::insert_region);
4692 ops.push_back (Operations::drag_region_brush);
4693 ops.push_back (Operations::region_drag);
4694 ops.push_back (Operations::selection_grab);
4695 ops.push_back (Operations::region_fill);
4696 ops.push_back (Operations::fill_selection);
4697 ops.push_back (Operations::create_region);
4698 ops.push_back (Operations::region_copy);
4699 ops.push_back (Operations::fixed_time_region_copy);
4702 /* See if any of the current operations match the ones that we want */
4704 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4706 /* If so, update the session range markers */
4708 maybe_update_session_range (r->position (), r->last_frame ());
4712 /** Update the session range markers if a is before the current start or
4713 * b is after the current end.
4716 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4718 if (_state_of_the_state & Loading) {
4722 framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4724 if (_session_range_location == 0) {
4726 set_session_range_location (a, b + session_end_marker_shift_samples);
4730 if (a < _session_range_location->start()) {
4731 _session_range_location->set_start (a);
4734 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4735 _session_range_location->set_end (b);
4741 Session::set_end_is_free (bool yn)
4743 _session_range_end_is_free = yn;
4747 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4749 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4750 maybe_update_session_range (i->to, i->to + i->length);
4755 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4757 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4758 maybe_update_session_range (i->from, i->to);
4762 /* Region management */
4764 boost::shared_ptr<Region>
4765 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4767 const RegionFactory::RegionMap& regions (RegionFactory::regions());
4768 RegionFactory::RegionMap::const_iterator i;
4769 boost::shared_ptr<Region> region;
4771 Glib::Threads::Mutex::Lock lm (region_lock);
4773 for (i = regions.begin(); i != regions.end(); ++i) {
4777 if (region->whole_file()) {
4779 if (child->source_equivalent (region)) {
4785 return boost::shared_ptr<Region> ();
4789 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4791 set<boost::shared_ptr<Region> > relevant_regions;
4793 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4794 RegionFactory::get_regions_using_source (*s, relevant_regions);
4797 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4798 set<boost::shared_ptr<Region> >::iterator tmp;
4803 playlists->destroy_region (*r);
4804 RegionFactory::map_remove (*r);
4806 (*r)->drop_sources ();
4807 (*r)->drop_references ();
4809 relevant_regions.erase (r);
4814 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4817 Glib::Threads::Mutex::Lock ls (source_lock);
4818 /* remove from the main source list */
4819 sources.erase ((*s)->id());
4822 (*s)->mark_for_remove ();
4823 (*s)->drop_references ();
4832 Session::remove_last_capture ()
4834 list<boost::shared_ptr<Source> > srcs;
4836 boost::shared_ptr<RouteList> rl = routes.reader ();
4837 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4838 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4843 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4846 srcs.insert (srcs.end(), l.begin(), l.end());
4851 destroy_sources (srcs);
4853 save_state (_current_snapshot_name);
4858 /* Source Management */
4861 Session::add_source (boost::shared_ptr<Source> source)
4863 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4864 pair<SourceMap::iterator,bool> result;
4866 entry.first = source->id();
4867 entry.second = source;
4870 Glib::Threads::Mutex::Lock lm (source_lock);
4871 result = sources.insert (entry);
4874 if (result.second) {
4876 /* yay, new source */
4878 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4881 if (!fs->within_session()) {
4882 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4888 boost::shared_ptr<AudioFileSource> afs;
4890 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4891 if (Config->get_auto_analyse_audio()) {
4892 Analyser::queue_source_for_analysis (source, false);
4896 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4901 Session::remove_source (boost::weak_ptr<Source> src)
4903 if (_state_of_the_state & Deletion) {
4907 SourceMap::iterator i;
4908 boost::shared_ptr<Source> source = src.lock();
4915 Glib::Threads::Mutex::Lock lm (source_lock);
4917 if ((i = sources.find (source->id())) != sources.end()) {
4922 if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4924 /* save state so we don't end up with a session file
4925 referring to non-existent sources.
4928 save_state (_current_snapshot_name);
4932 boost::shared_ptr<Source>
4933 Session::source_by_id (const PBD::ID& id)
4935 Glib::Threads::Mutex::Lock lm (source_lock);
4936 SourceMap::iterator i;
4937 boost::shared_ptr<Source> source;
4939 if ((i = sources.find (id)) != sources.end()) {
4946 boost::shared_ptr<AudioFileSource>
4947 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4949 /* Restricted to audio files because only audio sources have channel
4953 Glib::Threads::Mutex::Lock lm (source_lock);
4955 for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4956 boost::shared_ptr<AudioFileSource> afs
4957 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4959 if (afs && afs->path() == path && chn == afs->channel()) {
4964 return boost::shared_ptr<AudioFileSource>();
4967 boost::shared_ptr<MidiSource>
4968 Session::midi_source_by_path (const std::string& path, bool need_source_lock) const
4970 /* Restricted to MIDI files because audio sources require a channel
4971 for unique identification, in addition to a path.
4974 Glib::Threads::Mutex::Lock lm (source_lock, Glib::Threads::NOT_LOCK);
4975 if (need_source_lock) {
4979 for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4980 boost::shared_ptr<MidiSource> ms
4981 = boost::dynamic_pointer_cast<MidiSource>(s->second);
4982 boost::shared_ptr<FileSource> fs
4983 = boost::dynamic_pointer_cast<FileSource>(s->second);
4985 if (ms && fs && fs->path() == path) {
4990 return boost::shared_ptr<MidiSource>();
4994 Session::count_sources_by_origin (const string& path)
4997 Glib::Threads::Mutex::Lock lm (source_lock);
4999 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
5000 boost::shared_ptr<FileSource> fs
5001 = boost::dynamic_pointer_cast<FileSource>(i->second);
5003 if (fs && fs->origin() == path) {
5012 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
5014 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
5015 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
5017 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
5022 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
5024 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
5026 if (Glib::path_is_absolute (filepath)) {
5028 /* rip the session dir from the audiofile source */
5030 string session_path;
5031 bool in_another_session = true;
5033 if (filepath.find (interchange_dir_string) != string::npos) {
5035 session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
5036 session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
5037 session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
5038 session_path = Glib::path_get_dirname (session_path); /* now has session path */
5040 /* see if it is within our session */
5042 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5043 if (i->path == session_path) {
5044 in_another_session = false;
5049 in_another_session = false;
5053 if (in_another_session) {
5054 SessionDirectory sd (session_path);
5055 return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
5059 /* 1) if file belongs to this session
5060 * it may be a relative path (interchange/...)
5061 * or just basename (session_state, remove source)
5062 * -> just use the basename
5064 std::string filename = Glib::path_get_basename (filepath);
5067 /* 2) if the file is outside our session dir:
5068 * (imported but not copied) add the path for check-summming */
5070 path = Glib::path_get_dirname (filepath);
5073 return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
5077 Session::new_audio_source_path_for_embedded (const std::string& path)
5081 * we know that the filename is already unique because it exists
5082 * out in the filesystem.
5084 * However, when we bring it into the session, we could get a
5087 * Eg. two embedded files:
5092 * When merged into session, these collide.
5094 * There will not be a conflict with in-memory sources
5095 * because when the source was created we already picked
5096 * a unique name for it.
5098 * This collision is not likely to be common, but we have to guard
5099 * against it. So, if there is a collision, take the md5 hash of the
5100 * the path, and use that as the filename instead.
5103 SessionDirectory sdir (get_best_session_directory_for_new_audio());
5104 string base = Glib::path_get_basename (path);
5105 string newpath = Glib::build_filename (sdir.sound_path(), base);
5107 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5111 md5.digestString (path.c_str());
5112 md5.writeToString ();
5113 base = md5.digestChars;
5115 string ext = get_suffix (path);
5122 newpath = Glib::build_filename (sdir.sound_path(), base);
5124 /* if this collides, we're screwed */
5126 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
5127 error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
5136 /** Return true if there are no audio file sources that use @param name as
5137 * the filename component of their path.
5139 * Return false otherwise.
5141 * This method MUST ONLY be used to check in-session, mono files since it
5142 * hard-codes the channel of the audio file source we are looking for as zero.
5144 * If/when Ardour supports native files in non-mono formats, the logic here
5145 * will need to be revisited.
5148 Session::audio_source_name_is_unique (const string& name)
5150 std::vector<string> sdirs = source_search_path (DataType::AUDIO);
5151 vector<space_and_path>::iterator i;
5152 uint32_t existing = 0;
5154 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5156 /* note that we search *without* the extension so that
5157 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
5158 in the event that this new name is required for
5159 a file format change.
5162 const string spath = *i;
5164 if (matching_unsuffixed_filename_exists_in (spath, name)) {
5169 /* it is possible that we have the path already
5170 * assigned to a source that has not yet been written
5171 * (ie. the write source for a diskstream). we have to
5172 * check this in order to make sure that our candidate
5173 * path isn't used again, because that can lead to
5174 * two Sources point to the same file with different
5175 * notions of their removability.
5179 string possible_path = Glib::build_filename (spath, name);
5181 if (audio_source_by_path_and_channel (possible_path, 0)) {
5187 return (existing == 0);
5191 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)
5194 const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
5196 if (Profile->get_trx() && destructive) {
5198 sstr << setfill ('0') << setw (4) << cnt;
5199 sstr << legalized_base;
5201 sstr << legalized_base;
5203 if (take_required || related_exists) {
5215 } else if (nchan > 2) {
5220 /* XXX what? more than 26 channels! */
5231 /** Return a unique name based on \a base for a new internal audio source */
5233 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
5236 string possible_name;
5237 const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
5239 bool some_related_source_name_exists = false;
5241 legalized = legalize_for_path (base);
5243 // Find a "version" of the base name that doesn't exist in any of the possible directories.
5245 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
5247 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
5249 if (audio_source_name_is_unique (possible_name)) {
5253 some_related_source_name_exists = true;
5256 error << string_compose(
5257 _("There are already %1 recordings for %2, which I consider too many."),
5258 limit, base) << endmsg;
5260 throw failed_constructor();
5264 /* We've established that the new name does not exist in any session
5265 * directory, so now find out which one we should use for this new
5269 SessionDirectory sdir (get_best_session_directory_for_new_audio());
5271 std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
5276 /** Return a unique name based on `base` for a new internal MIDI source */
5278 Session::new_midi_source_path (const string& base, bool need_lock)
5281 char buf[PATH_MAX+1];
5282 const uint32_t limit = 10000;
5284 string possible_path;
5285 string possible_name;
5288 legalized = legalize_for_path (base);
5290 // Find a "version" of the file name that doesn't exist in any of the possible directories.
5291 std::vector<string> sdirs = source_search_path(DataType::MIDI);
5293 /* - the main session folder is the first in the vector.
5294 * - after checking all locations for file-name uniqueness,
5295 * we keep the one from the last iteration as new file name
5296 * - midi files are small and should just be kept in the main session-folder
5298 * -> reverse the array, check main session folder last and use that as location
5301 std::reverse(sdirs.begin(), sdirs.end());
5303 for (cnt = 1; cnt <= limit; ++cnt) {
5305 vector<space_and_path>::iterator i;
5306 uint32_t existing = 0;
5308 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
5310 snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
5311 possible_name = buf;
5313 possible_path = Glib::build_filename (*i, possible_name);
5315 if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
5319 if (midi_source_by_path (possible_path, need_lock)) {
5324 if (existing == 0) {
5329 error << string_compose(
5330 _("There are already %1 recordings for %2, which I consider too many."),
5331 limit, base) << endmsg;
5337 /* No need to "find best location" for software/app-based RAID, because
5338 MIDI is so small that we always put it in the same place.
5341 return possible_path;
5345 /** Create a new within-session audio source */
5346 boost::shared_ptr<AudioFileSource>
5347 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5349 const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5351 if (!path.empty()) {
5352 return boost::dynamic_pointer_cast<AudioFileSource> (
5353 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
5355 throw failed_constructor ();
5359 /** Create a new within-session MIDI source */
5360 boost::shared_ptr<MidiSource>
5361 Session::create_midi_source_for_session (string const & basic_name)
5363 const string path = new_midi_source_path (basic_name);
5365 if (!path.empty()) {
5366 return boost::dynamic_pointer_cast<SMFSource> (
5367 SourceFactory::createWritable (
5368 DataType::MIDI, *this, path, false, frame_rate()));
5370 throw failed_constructor ();
5374 /** Create a new within-session MIDI source */
5375 boost::shared_ptr<MidiSource>
5376 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5378 /* the caller passes in the track the source will be used in,
5379 so that we can keep the numbering sane.
5381 Rationale: a track with the name "Foo" that has had N
5382 captures carried out so far will ALREADY have a write source
5383 named "Foo-N+1.mid" waiting to be used for the next capture.
5385 If we call new_midi_source_name() we will get "Foo-N+2". But
5386 there is no region corresponding to "Foo-N+1", so when
5387 "Foo-N+2" appears in the track, the gap presents the user
5388 with odd behaviour - why did it skip past Foo-N+1?
5390 We could explain this to the user in some odd way, but
5391 instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5394 If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5397 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5399 std::string name = track->steal_write_source_name ();
5402 return boost::shared_ptr<MidiSource>();
5405 /* MIDI files are small, just put them in the first location of the
5406 session source search path.
5409 const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5411 return boost::dynamic_pointer_cast<SMFSource> (
5412 SourceFactory::createWritable (
5413 DataType::MIDI, *this, path, false, frame_rate()));
5418 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5420 if (playlist->hidden()) {
5424 playlists->add (playlist);
5427 playlist->release();
5434 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5436 if (_state_of_the_state & Deletion) {
5440 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5446 playlists->remove (playlist);
5452 Session::set_audition (boost::shared_ptr<Region> r)
5454 pending_audition_region = r;
5455 add_post_transport_work (PostTransportAudition);
5456 _butler->schedule_transport_work ();
5460 Session::audition_playlist ()
5462 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5463 ev->region.reset ();
5469 Session::register_lua_function (
5470 const std::string& name,
5471 const std::string& script,
5472 const LuaScriptParamList& args
5475 Glib::Threads::Mutex::Lock lm (lua_lock);
5477 lua_State* L = lua.getState();
5479 const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5480 luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5481 for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5482 if ((*i)->optional && !(*i)->is_set) { continue; }
5483 tbl_arg[(*i)->name] = (*i)->value;
5485 (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5488 LuaScriptsChanged (); /* EMIT SIGNAL */
5493 Session::unregister_lua_function (const std::string& name)
5495 Glib::Threads::Mutex::Lock lm (lua_lock);
5496 (*_lua_del)(name); // throws luabridge::LuaException
5497 lua.collect_garbage ();
5500 LuaScriptsChanged (); /* EMIT SIGNAL */
5504 std::vector<std::string>
5505 Session::registered_lua_functions ()
5507 Glib::Threads::Mutex::Lock lm (lua_lock);
5508 std::vector<std::string> rv;
5511 luabridge::LuaRef list ((*_lua_list)());
5512 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5513 if (!i.key ().isString ()) { assert(0); continue; }
5514 rv.push_back (i.key ().cast<std::string> ());
5516 } catch (luabridge::LuaException const& e) { }
5521 static void _lua_print (std::string s) {
5522 std::cout << "SessionLua: " << s << "\n";
5527 Session::try_run_lua (pframes_t nframes)
5529 if (_n_lua_scripts == 0) return;
5530 Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5532 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5533 lua.collect_garbage_step ();
5538 Session::setup_lua ()
5541 lua.Print.connect (&_lua_print);
5546 "function ArdourSession ()"
5547 " local self = { scripts = {}, instances = {} }"
5549 " local remove = function (n)"
5550 " self.scripts[n] = nil"
5551 " self.instances[n] = nil"
5552 " Session:scripts_changed()" // call back
5555 " local addinternal = function (n, f, a)"
5556 " assert(type(n) == 'string', 'function-name must be string')"
5557 " assert(type(f) == 'function', 'Given script is a not a function')"
5558 " assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5559 " assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5560 " self.scripts[n] = { ['f'] = f, ['a'] = a }"
5561 " 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 }"
5562 " self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5563 " Session:scripts_changed()" // call back
5566 " local add = function (n, b, a)"
5567 " assert(type(b) == 'string', 'ByteCode must be string')"
5568 " load (b)()" // assigns f
5569 " assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5570 " addinternal (n, load(f), a)"
5573 " local run = function (...)"
5574 " for n, s in pairs (self.instances) do"
5575 " local status, err = pcall (s, ...)"
5576 " if not status then"
5577 " print ('fn \"'.. n .. '\": ', err)"
5584 " local cleanup = function ()"
5585 " self.scripts = nil"
5586 " self.instances = nil"
5589 " local list = function ()"
5591 " for n, _ in pairs (self.scripts) do"
5597 " local function basic_serialize (o)"
5598 " if type(o) == \"number\" then"
5599 " return tostring(o)"
5601 " return string.format(\"%q\", o)"
5605 " local function serialize (name, value)"
5606 " local rv = name .. ' = '"
5608 " if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5609 " return rv .. basic_serialize(value) .. ' '"
5610 " elseif type(value) == \"table\" then"
5612 " for k,v in pairs(value) do"
5613 " local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5614 " rv = rv .. serialize(fieldname, v) .. ' '"
5615 " collectgarbage()" // string concatenation allocates a new string :(
5618 " elseif type(value) == \"function\" then"
5619 " return rv .. string.format(\"%q\", string.dump(value, true))"
5621 " error('cannot save a ' .. type(value))"
5626 " local save = function ()"
5627 " return (serialize('scripts', self.scripts))"
5630 " local restore = function (state)"
5631 " self.scripts = {}"
5633 " for n, s in pairs (scripts) do"
5634 " addinternal (n, load(s['f']), s['a'])"
5638 " return { run = run, add = add, remove = remove,"
5639 " list = list, restore = restore, save = save, cleanup = cleanup}"
5642 " sess = ArdourSession ()"
5643 " ArdourSession = nil"
5645 "function ardour () end"
5648 lua_State* L = lua.getState();
5651 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5652 lua.do_command ("sess = nil"); // hide it.
5653 lua.do_command ("collectgarbage()");
5655 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5656 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5657 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5658 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5659 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5660 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5661 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5662 } catch (luabridge::LuaException const& e) {
5663 fatal << string_compose (_("programming error: %1"),
5664 X_("Failed to setup Lua interpreter"))
5666 abort(); /*NOTREACHED*/
5669 LuaBindings::stddef (L);
5670 LuaBindings::common (L);
5671 LuaBindings::dsp (L);
5672 luabridge::push <Session *> (L, this);
5673 lua_setglobal (L, "Session");
5677 Session::scripts_changed ()
5679 assert (!lua_lock.trylock()); // must hold lua_lock
5682 luabridge::LuaRef list ((*_lua_list)());
5684 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5685 if (!i.key ().isString ()) { assert(0); continue; }
5688 _n_lua_scripts = cnt;
5689 } catch (luabridge::LuaException const& e) {
5690 fatal << string_compose (_("programming error: %1"),
5691 X_("Indexing Lua Session Scripts failed."))
5693 abort(); /*NOTREACHED*/
5698 Session::non_realtime_set_audition ()
5700 assert (pending_audition_region);
5701 auditioner->audition_region (pending_audition_region);
5702 pending_audition_region.reset ();
5703 AuditionActive (true); /* EMIT SIGNAL */
5707 Session::audition_region (boost::shared_ptr<Region> r)
5709 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5715 Session::cancel_audition ()
5720 if (auditioner->auditioning()) {
5721 auditioner->cancel_audition ();
5722 AuditionActive (false); /* EMIT SIGNAL */
5727 Session::is_auditioning () const
5729 /* can be called before we have an auditioner object */
5731 return auditioner->auditioning();
5738 Session::graph_reordered ()
5740 /* don't do this stuff if we are setting up connections
5741 from a set_state() call or creating new tracks. Ditto for deletion.
5744 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5748 /* every track/bus asked for this to be handled but it was deferred because
5749 we were connecting. do it now.
5752 request_input_change_handling ();
5756 /* force all diskstreams to update their capture offset values to
5757 reflect any changes in latencies within the graph.
5760 boost::shared_ptr<RouteList> rl = routes.reader ();
5761 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5762 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5764 tr->set_capture_offset ();
5769 /** @return Number of frames that there is disk space available to write,
5772 boost::optional<framecnt_t>
5773 Session::available_capture_duration ()
5775 Glib::Threads::Mutex::Lock lm (space_lock);
5777 if (_total_free_4k_blocks_uncertain) {
5778 return boost::optional<framecnt_t> ();
5781 float sample_bytes_on_disk = 4.0; // keep gcc happy
5783 switch (config.get_native_file_data_format()) {
5785 sample_bytes_on_disk = 4.0;
5789 sample_bytes_on_disk = 3.0;
5793 sample_bytes_on_disk = 2.0;
5797 /* impossible, but keep some gcc versions happy */
5798 fatal << string_compose (_("programming error: %1"),
5799 X_("illegal native file data format"))
5801 abort(); /*NOTREACHED*/
5804 double scale = 4096.0 / sample_bytes_on_disk;
5806 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5807 return max_framecnt;
5810 return (framecnt_t) floor (_total_free_4k_blocks * scale);
5814 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5817 RCUWriter<BundleList> writer (_bundles);
5818 boost::shared_ptr<BundleList> b = writer.get_copy ();
5819 b->push_back (bundle);
5823 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5830 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5832 bool removed = false;
5835 RCUWriter<BundleList> writer (_bundles);
5836 boost::shared_ptr<BundleList> b = writer.get_copy ();
5837 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5839 if (i != b->end()) {
5846 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5852 boost::shared_ptr<Bundle>
5853 Session::bundle_by_name (string name) const
5855 boost::shared_ptr<BundleList> b = _bundles.reader ();
5857 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5858 if ((*i)->name() == name) {
5863 return boost::shared_ptr<Bundle> ();
5867 Session::tempo_map_changed (const PropertyChange&)
5871 playlists->update_after_tempo_map_change ();
5873 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5879 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5881 for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5882 (*i)->recompute_frames_from_beat ();
5886 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5887 * the given count with the current block size.
5890 Session::ensure_buffers (ChanCount howmany)
5892 BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5896 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5898 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5899 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5904 Session::next_insert_id ()
5906 /* this doesn't really loop forever. just think about it */
5909 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5910 if (!insert_bitset[n]) {
5911 insert_bitset[n] = true;
5917 /* none available, so resize and try again */
5919 insert_bitset.resize (insert_bitset.size() + 16, false);
5924 Session::next_send_id ()
5926 /* this doesn't really loop forever. just think about it */
5929 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5930 if (!send_bitset[n]) {
5931 send_bitset[n] = true;
5937 /* none available, so resize and try again */
5939 send_bitset.resize (send_bitset.size() + 16, false);
5944 Session::next_aux_send_id ()
5946 /* this doesn't really loop forever. just think about it */
5949 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5950 if (!aux_send_bitset[n]) {
5951 aux_send_bitset[n] = true;
5957 /* none available, so resize and try again */
5959 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5964 Session::next_return_id ()
5966 /* this doesn't really loop forever. just think about it */
5969 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5970 if (!return_bitset[n]) {
5971 return_bitset[n] = true;
5977 /* none available, so resize and try again */
5979 return_bitset.resize (return_bitset.size() + 16, false);
5984 Session::mark_send_id (uint32_t id)
5986 if (id >= send_bitset.size()) {
5987 send_bitset.resize (id+16, false);
5989 if (send_bitset[id]) {
5990 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5992 send_bitset[id] = true;
5996 Session::mark_aux_send_id (uint32_t id)
5998 if (id >= aux_send_bitset.size()) {
5999 aux_send_bitset.resize (id+16, false);
6001 if (aux_send_bitset[id]) {
6002 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
6004 aux_send_bitset[id] = true;
6008 Session::mark_return_id (uint32_t id)
6010 if (id >= return_bitset.size()) {
6011 return_bitset.resize (id+16, false);
6013 if (return_bitset[id]) {
6014 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
6016 return_bitset[id] = true;
6020 Session::mark_insert_id (uint32_t id)
6022 if (id >= insert_bitset.size()) {
6023 insert_bitset.resize (id+16, false);
6025 if (insert_bitset[id]) {
6026 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
6028 insert_bitset[id] = true;
6032 Session::unmark_send_id (uint32_t id)
6034 if (id < send_bitset.size()) {
6035 send_bitset[id] = false;
6040 Session::unmark_aux_send_id (uint32_t id)
6042 if (id < aux_send_bitset.size()) {
6043 aux_send_bitset[id] = false;
6048 Session::unmark_return_id (uint32_t id)
6050 if (_state_of_the_state & Deletion) { return; }
6051 if (id < return_bitset.size()) {
6052 return_bitset[id] = false;
6057 Session::unmark_insert_id (uint32_t id)
6059 if (id < insert_bitset.size()) {
6060 insert_bitset[id] = false;
6065 Session::reset_native_file_format ()
6067 boost::shared_ptr<RouteList> rl = routes.reader ();
6069 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6070 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6072 /* don't save state as we do this, there's no point
6074 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
6075 tr->reset_write_sources (false);
6076 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
6082 Session::route_name_unique (string n) const
6084 boost::shared_ptr<RouteList> r = routes.reader ();
6086 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6087 if ((*i)->name() == n) {
6096 Session::route_name_internal (string n) const
6098 if (auditioner && auditioner->name() == n) {
6102 if (_click_io && _click_io->name() == n) {
6110 Session::freeze_all (InterThreadInfo& itt)
6112 boost::shared_ptr<RouteList> r = routes.reader ();
6114 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6116 boost::shared_ptr<Track> t;
6118 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
6119 /* XXX this is wrong because itt.progress will keep returning to zero at the start
6129 boost::shared_ptr<Region>
6130 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
6131 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
6132 InterThreadInfo& itt,
6133 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
6134 bool for_export, bool for_freeze)
6136 boost::shared_ptr<Region> result;
6137 boost::shared_ptr<Playlist> playlist;
6138 boost::shared_ptr<Source> source;
6139 ChanCount diskstream_channels (track.n_channels());
6140 framepos_t position;
6141 framecnt_t this_chunk;
6143 framepos_t latency_skip;
6145 framepos_t len = end - start;
6146 bool need_block_size_reset = false;
6147 ChanCount const max_proc = track.max_processor_streams ();
6148 string legal_playlist_name;
6149 string possible_path;
6152 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
6153 end, start) << endmsg;
6157 diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
6158 include_endpoint, for_export, for_freeze);
6160 if (diskstream_channels.n(track.data_type()) < 1) {
6161 error << _("Cannot write a range with no data.") << endmsg;
6165 // block all process callback handling
6167 block_processing ();
6170 // synchronize with AudioEngine::process_callback()
6171 // make sure processing is not currently running
6172 // and processing_blocked() is honored before
6173 // acquiring thread buffers
6174 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6177 _bounce_processing_active = true;
6179 /* call tree *MUST* hold route_lock */
6181 if ((playlist = track.playlist()) == 0) {
6185 legal_playlist_name = legalize_for_path (playlist->name());
6187 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
6189 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
6190 string path = ((track.data_type() == DataType::AUDIO)
6191 ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
6192 : new_midi_source_path (legal_playlist_name));
6199 source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
6202 catch (failed_constructor& err) {
6203 error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
6207 srcs.push_back (source);
6210 /* tell redirects that care that we are about to use a much larger
6211 * blocksize. this will flush all plugins too, so that they are ready
6212 * to be used for this process.
6215 need_block_size_reset = true;
6216 track.set_block_size (bounce_chunk_size);
6217 _engine.main_thread()->get_buffers ();
6221 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6223 /* create a set of reasonably-sized buffers */
6224 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6225 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
6227 buffers.set_count (max_proc);
6229 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6230 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6231 boost::shared_ptr<MidiSource> ms;
6233 afs->prepare_for_peakfile_writes ();
6234 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6235 Source::Lock lock(ms->mutex());
6236 ms->mark_streaming_write_started(lock);
6240 while (to_do && !itt.cancel) {
6242 this_chunk = min (to_do, bounce_chunk_size);
6244 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
6248 start += this_chunk;
6249 to_do -= this_chunk;
6250 itt.progress = (float) (1.0 - ((double) to_do / len));
6252 if (latency_skip >= bounce_chunk_size) {
6253 latency_skip -= bounce_chunk_size;
6257 const framecnt_t current_chunk = this_chunk - latency_skip;
6260 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6261 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6262 boost::shared_ptr<MidiSource> ms;
6265 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
6268 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6269 Source::Lock lock(ms->mutex());
6271 const MidiBuffer& buf = buffers.get_midi(0);
6272 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
6273 Evoral::Event<framepos_t> ev = *i;
6274 ev.set_time(ev.time() - position);
6275 ms->append_event_frames(lock, ev, ms->timeline_position());
6282 /* post-roll, pick up delayed processor output */
6283 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
6285 while (latency_skip && !itt.cancel) {
6286 this_chunk = min (latency_skip, bounce_chunk_size);
6287 latency_skip -= this_chunk;
6289 buffers.silence (this_chunk, 0);
6290 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
6293 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
6294 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6297 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
6309 xnow = localtime (&now);
6311 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
6312 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6313 boost::shared_ptr<MidiSource> ms;
6316 afs->update_header (position, *xnow, now);
6317 afs->flush_header ();
6318 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
6319 Source::Lock lock(ms->mutex());
6320 ms->mark_streaming_write_completed(lock);
6324 /* construct a region to represent the bounced material */
6328 plist.add (Properties::start, 0);
6329 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6330 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6332 result = RegionFactory::create (srcs, plist);
6338 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6339 (*src)->mark_for_remove ();
6340 (*src)->drop_references ();
6344 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6345 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6348 afs->done_with_peakfile_writes ();
6352 _bounce_processing_active = false;
6354 if (need_block_size_reset) {
6355 _engine.main_thread()->drop_buffers ();
6356 track.set_block_size (get_block_size());
6359 unblock_processing ();
6365 Session::gain_automation_buffer() const
6367 return ProcessThread::gain_automation_buffer ();
6371 Session::trim_automation_buffer() const
6373 return ProcessThread::trim_automation_buffer ();
6377 Session::send_gain_automation_buffer() const
6379 return ProcessThread::send_gain_automation_buffer ();
6383 Session::scratch_automation_buffer() const
6385 return ProcessThread::scratch_automation_buffer ();
6389 Session::pan_automation_buffer() const
6391 return ProcessThread::pan_automation_buffer ();
6395 Session::get_silent_buffers (ChanCount count)
6397 return ProcessThread::get_silent_buffers (count);
6401 Session::get_scratch_buffers (ChanCount count, bool silence)
6403 return ProcessThread::get_scratch_buffers (count, silence);
6407 Session::get_noinplace_buffers (ChanCount count)
6409 return ProcessThread::get_noinplace_buffers (count);
6413 Session::get_route_buffers (ChanCount count, bool silence)
6415 return ProcessThread::get_route_buffers (count, silence);
6420 Session::get_mix_buffers (ChanCount count)
6422 return ProcessThread::get_mix_buffers (count);
6426 Session::ntracks () const
6429 boost::shared_ptr<RouteList> r = routes.reader ();
6431 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6432 if (boost::dynamic_pointer_cast<Track> (*i)) {
6441 Session::nbusses () const
6444 boost::shared_ptr<RouteList> r = routes.reader ();
6446 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6447 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6456 Session::nstripables (bool with_monitor) const
6458 uint32_t rv = routes.reader()->size ();
6459 rv += _vca_manager->vcas ().size ();
6473 Session::add_automation_list(AutomationList *al)
6475 automation_lists[al->id()] = al;
6478 /** @return true if there is at least one record-enabled track, otherwise false */
6480 Session::have_rec_enabled_track () const
6482 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6486 Session::have_rec_disabled_track () const
6488 return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6491 /** Update the state of our rec-enabled tracks flag */
6493 Session::update_route_record_state ()
6495 boost::shared_ptr<RouteList> rl = routes.reader ();
6496 RouteList::iterator i = rl->begin();
6497 while (i != rl->end ()) {
6499 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6500 if (tr && tr->rec_enable_control()->get_value()) {
6507 int const old = g_atomic_int_get (&_have_rec_enabled_track);
6509 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6511 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6512 RecordStateChanged (); /* EMIT SIGNAL */
6515 for (i = rl->begin(); i != rl->end (); ++i) {
6516 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6517 if (tr && !tr->rec_enable_control()->get_value()) {
6522 g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6524 bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6526 if (record_status() == Recording && record_arm_state_changed ) {
6527 RecordArmStateChanged ();
6533 Session::listen_position_changed ()
6535 ProcessorChangeBlocker pcb (this);
6536 boost::shared_ptr<RouteList> r = routes.reader ();
6537 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6538 (*i)->listen_position_changed ();
6543 Session::solo_control_mode_changed ()
6545 if (soloing() || listening()) {
6547 /* We can't use ::clear_all_solo_state() here because during
6548 session loading at program startup, that will queue a call
6549 to rt_clear_all_solo_state() that will not execute until
6550 AFTER solo states have been established (thus throwing away
6551 the session's saved solo state). So just explicitly turn
6554 set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6556 clear_all_solo_state (get_routes());
6561 /** Called when a property of one of our route groups changes */
6563 Session::route_group_property_changed (RouteGroup* rg)
6565 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6568 /** Called when a route is added to one of our route groups */
6570 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6572 RouteAddedToRouteGroup (rg, r);
6575 /** Called when a route is removed from one of our route groups */
6577 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6579 update_route_record_state ();
6580 RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6582 if (!rg->has_control_master () && !rg->has_subgroup () && rg->empty()) {
6583 remove_route_group (*rg);
6587 boost::shared_ptr<RouteList>
6588 Session::get_tracks () const
6590 boost::shared_ptr<RouteList> rl = routes.reader ();
6591 boost::shared_ptr<RouteList> tl (new RouteList);
6593 for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6594 if (boost::dynamic_pointer_cast<Track> (*r)) {
6595 assert (!(*r)->is_auditioner()); // XXX remove me
6602 boost::shared_ptr<RouteList>
6603 Session::get_routes_with_regions_at (framepos_t const p) const
6605 boost::shared_ptr<RouteList> r = routes.reader ();
6606 boost::shared_ptr<RouteList> rl (new RouteList);
6608 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6609 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6614 boost::shared_ptr<Playlist> pl = tr->playlist ();
6619 if (pl->has_region_at (p)) {
6628 Session::goto_end ()
6630 if (_session_range_location) {
6631 request_locate (_session_range_location->end(), false);
6633 request_locate (0, false);
6638 Session::goto_start (bool and_roll)
6640 if (_session_range_location) {
6641 request_locate (_session_range_location->start(), and_roll);
6643 request_locate (0, and_roll);
6648 Session::current_start_frame () const
6650 return _session_range_location ? _session_range_location->start() : 0;
6654 Session::current_end_frame () const
6656 return _session_range_location ? _session_range_location->end() : 0;
6660 Session::set_session_range_location (framepos_t start, framepos_t end)
6662 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange, 0);
6663 _locations->add (_session_range_location);
6667 Session::step_edit_status_change (bool yn)
6673 send = (_step_editors == 0);
6678 send = (_step_editors == 1);
6681 if (_step_editors > 0) {
6687 StepEditStatusChange (val);
6693 Session::start_time_changed (framepos_t old)
6695 /* Update the auto loop range to match the session range
6696 (unless the auto loop range has been changed by the user)
6699 Location* s = _locations->session_range_location ();
6704 Location* l = _locations->auto_loop_location ();
6706 if (l && l->start() == old) {
6707 l->set_start (s->start(), true);
6713 Session::end_time_changed (framepos_t old)
6715 /* Update the auto loop range to match the session range
6716 (unless the auto loop range has been changed by the user)
6719 Location* s = _locations->session_range_location ();
6724 Location* l = _locations->auto_loop_location ();
6726 if (l && l->end() == old) {
6727 l->set_end (s->end(), true);
6732 std::vector<std::string>
6733 Session::source_search_path (DataType type) const
6737 if (session_dirs.size() == 1) {
6739 case DataType::AUDIO:
6740 sp.push_back (_session_dir->sound_path());
6742 case DataType::MIDI:
6743 sp.push_back (_session_dir->midi_path());
6747 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6748 SessionDirectory sdir (i->path);
6750 case DataType::AUDIO:
6751 sp.push_back (sdir.sound_path());
6753 case DataType::MIDI:
6754 sp.push_back (sdir.midi_path());
6760 if (type == DataType::AUDIO) {
6761 const string sound_path_2X = _session_dir->sound_path_2X();
6762 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6763 if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6764 sp.push_back (sound_path_2X);
6769 // now check the explicit (possibly user-specified) search path
6772 case DataType::AUDIO:
6773 sp += Searchpath(config.get_audio_search_path ());
6775 case DataType::MIDI:
6776 sp += Searchpath(config.get_midi_search_path ());
6784 Session::ensure_search_path_includes (const string& path, DataType type)
6793 case DataType::AUDIO:
6794 sp += Searchpath(config.get_audio_search_path ());
6796 case DataType::MIDI:
6797 sp += Searchpath (config.get_midi_search_path ());
6801 for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6802 /* No need to add this new directory if it has the same inode as
6803 an existing one; checking inode rather than name prevents duplicated
6804 directories when we are using symlinks.
6806 On Windows, I think we could just do if (*i == path) here.
6808 if (PBD::equivalent_paths (*i, path)) {
6816 case DataType::AUDIO:
6817 config.set_audio_search_path (sp.to_string());
6819 case DataType::MIDI:
6820 config.set_midi_search_path (sp.to_string());
6826 Session::remove_dir_from_search_path (const string& dir, DataType type)
6831 case DataType::AUDIO:
6832 sp = Searchpath(config.get_audio_search_path ());
6834 case DataType::MIDI:
6835 sp = Searchpath (config.get_midi_search_path ());
6842 case DataType::AUDIO:
6843 config.set_audio_search_path (sp.to_string());
6845 case DataType::MIDI:
6846 config.set_midi_search_path (sp.to_string());
6852 boost::shared_ptr<Speakers>
6853 Session::get_speakers()
6859 Session::unknown_processors () const
6863 boost::shared_ptr<RouteList> r = routes.reader ();
6864 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6865 list<string> t = (*i)->unknown_processors ();
6866 copy (t.begin(), t.end(), back_inserter (p));
6876 Session::update_latency (bool playback)
6879 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6881 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6884 if (!_engine.running()) {
6888 boost::shared_ptr<RouteList> r = routes.reader ();
6889 framecnt_t max_latency = 0;
6892 /* reverse the list so that we work backwards from the last route to run to the first */
6893 RouteList* rl = routes.reader().get();
6894 r.reset (new RouteList (*rl));
6895 reverse (r->begin(), r->end());
6898 /* compute actual latency values for the given direction and store them all in per-port
6899 structures. this will also publish the same values (to JACK) so that computation of latency
6900 for routes can consistently use public latency values.
6903 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6904 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6907 /* because we latency compensate playback, our published playback latencies should
6908 be the same for all output ports - all material played back by ardour has
6909 the same latency, whether its caused by plugins or by latency compensation. since
6910 these may differ from the values computed above, reset all playback port latencies
6914 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6916 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6917 (*i)->set_public_port_latencies (max_latency, playback);
6922 post_playback_latency ();
6926 post_capture_latency ();
6929 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6933 Session::post_playback_latency ()
6935 set_worst_playback_latency ();
6937 boost::shared_ptr<RouteList> r = routes.reader ();
6939 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6940 assert (!(*i)->is_auditioner()); // XXX remove me
6941 if ((*i)->active()) {
6942 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6946 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6947 (*i)->set_latency_compensation (_worst_track_latency);
6952 Session::post_capture_latency ()
6954 set_worst_capture_latency ();
6956 /* reflect any changes in capture latencies into capture offsets
6959 boost::shared_ptr<RouteList> rl = routes.reader();
6960 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6961 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6963 tr->set_capture_offset ();
6969 Session::initialize_latencies ()
6972 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6973 update_latency (false);
6974 update_latency (true);
6977 set_worst_io_latencies ();
6981 Session::set_worst_io_latencies ()
6983 set_worst_playback_latency ();
6984 set_worst_capture_latency ();
6988 Session::set_worst_playback_latency ()
6990 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6994 _worst_output_latency = 0;
6996 if (!_engine.connected()) {
7000 boost::shared_ptr<RouteList> r = routes.reader ();
7002 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7003 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
7006 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
7010 Session::set_worst_capture_latency ()
7012 if (_state_of_the_state & (InitialConnecting|Deletion)) {
7016 _worst_input_latency = 0;
7018 if (!_engine.connected()) {
7022 boost::shared_ptr<RouteList> r = routes.reader ();
7024 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7025 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
7028 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
7032 Session::update_latency_compensation (bool force_whole_graph)
7034 bool some_track_latency_changed = false;
7036 if (_state_of_the_state & (InitialConnecting|Deletion)) {
7040 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
7042 _worst_track_latency = 0;
7044 boost::shared_ptr<RouteList> r = routes.reader ();
7046 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7047 assert (!(*i)->is_auditioner()); // XXX remove me
7048 if ((*i)->active()) {
7050 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
7051 some_track_latency_changed = true;
7053 _worst_track_latency = max (tl, _worst_track_latency);
7057 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
7058 (some_track_latency_changed ? "yes" : "no")));
7060 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
7062 if (some_track_latency_changed || force_whole_graph) {
7063 _engine.update_latencies ();
7067 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
7068 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
7072 tr->set_capture_offset ();
7077 Session::session_name_is_legal (const string& path)
7079 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
7081 for (int i = 0; illegal_chars[i]; ++i) {
7082 if (path.find (illegal_chars[i]) != string::npos) {
7083 return illegal_chars[i];
7091 Session::notify_presentation_info_change ()
7093 if (deletion_in_progress()) {
7097 reassign_track_numbers();
7099 #ifdef USE_TRACKS_CODE_FEATURES
7100 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
7101 * if track order has been changed by user
7103 reconnect_existing_routes(true, true);
7109 Session::operation_in_progress (GQuark op) const
7111 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
7114 boost::shared_ptr<Port>
7115 Session::ltc_input_port () const
7117 assert (_ltc_input);
7118 return _ltc_input->nth (0);
7121 boost::shared_ptr<Port>
7122 Session::ltc_output_port () const
7124 return _ltc_output ? _ltc_output->nth (0) : boost::shared_ptr<Port> ();
7128 Session::reconnect_ltc_input ()
7132 string src = Config->get_ltc_source_port();
7134 _ltc_input->disconnect (this);
7136 if (src != _("None") && !src.empty()) {
7137 _ltc_input->nth (0)->connect (src);
7140 if ( ARDOUR::Profile->get_trx () ) {
7141 // Tracks need this signal to update timecode_source_dropdown
7142 MtcOrLtcInputPortChanged (); //emit signal
7148 Session::reconnect_ltc_output ()
7152 string src = Config->get_ltc_output_port();
7154 _ltc_output->disconnect (this);
7156 if (src != _("None") && !src.empty()) {
7157 _ltc_output->nth (0)->connect (src);
7163 Session::set_range_selection (framepos_t start, framepos_t end)
7165 _range_selection = Evoral::Range<framepos_t> (start, end);
7166 #ifdef USE_TRACKS_CODE_FEATURES
7167 follow_playhead_priority ();
7172 Session::set_object_selection (framepos_t start, framepos_t end)
7174 _object_selection = Evoral::Range<framepos_t> (start, end);
7175 #ifdef USE_TRACKS_CODE_FEATURES
7176 follow_playhead_priority ();
7181 Session::clear_range_selection ()
7183 _range_selection = Evoral::Range<framepos_t> (-1,-1);
7184 #ifdef USE_TRACKS_CODE_FEATURES
7185 follow_playhead_priority ();
7190 Session::clear_object_selection ()
7192 _object_selection = Evoral::Range<framepos_t> (-1,-1);
7193 #ifdef USE_TRACKS_CODE_FEATURES
7194 follow_playhead_priority ();
7199 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
7200 const ChanCount& input_start,
7201 const ChanCount& output_start,
7202 const ChanCount& input_offset,
7203 const ChanCount& output_offset)
7205 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7206 _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
7207 input_start, output_start,
7208 input_offset, output_offset));
7210 auto_connect_thread_wakeup ();
7214 Session::auto_connect_thread_wakeup ()
7216 if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
7217 pthread_cond_signal (&_auto_connect_cond);
7218 pthread_mutex_unlock (&_auto_connect_mutex);
7223 Session::queue_latency_recompute ()
7225 g_atomic_int_inc (&_latency_recompute_pending);
7226 auto_connect_thread_wakeup ();
7230 Session::auto_connect (const AutoConnectRequest& ar)
7232 boost::shared_ptr<Route> route = ar.route.lock();
7234 if (!route) { return; }
7236 if (!IO::connecting_legal) {
7240 /* If both inputs and outputs are auto-connected to physical ports,
7241 * use the max of input and output offsets to ensure auto-connected
7242 * port numbers always match up (e.g. the first audio input and the
7243 * first audio output of the route will have the same physical
7244 * port number). Otherwise just use the lowest input or output
7248 const bool in_out_physical =
7249 (Config->get_input_auto_connect() & AutoConnectPhysical)
7250 && (Config->get_output_auto_connect() & AutoConnectPhysical)
7251 && ar.connect_inputs;
7253 const ChanCount in_offset = in_out_physical
7254 ? ChanCount::max(ar.input_offset, ar.output_offset)
7257 const ChanCount out_offset = in_out_physical
7258 ? ChanCount::max(ar.input_offset, ar.output_offset)
7261 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
7262 vector<string> physinputs;
7263 vector<string> physoutputs;
7266 /* for connecting track inputs we only want MIDI ports marked
7270 get_physical_ports (physinputs, physoutputs, *t, MidiPortMusic);
7272 if (!physinputs.empty() && ar.connect_inputs) {
7273 uint32_t nphysical_in = physinputs.size();
7275 for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
7278 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
7279 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
7282 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
7288 if (!physoutputs.empty()) {
7289 uint32_t nphysical_out = physoutputs.size();
7290 for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
7294 * do not create new connections if we reached the limit of physical outputs
7297 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
7298 ARDOUR::Profile->get_trx () &&
7299 ar.output_offset.get(*t) == nphysical_out ) {
7303 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
7304 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
7305 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
7306 /* master bus is audio only */
7307 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
7308 port = _master_out->input()->ports().port(*t,
7309 i % _master_out->input()->n_ports().get(*t))->name();
7313 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
7322 Session::auto_connect_thread_start ()
7324 if (g_atomic_int_get (&_ac_thread_active)) {
7328 while (!_auto_connect_queue.empty ()) {
7329 _auto_connect_queue.pop ();
7332 g_atomic_int_set (&_ac_thread_active, 1);
7333 if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
7334 g_atomic_int_set (&_ac_thread_active, 0);
7339 Session::auto_connect_thread_terminate ()
7341 if (!g_atomic_int_get (&_ac_thread_active)) {
7346 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7347 while (!_auto_connect_queue.empty ()) {
7348 _auto_connect_queue.pop ();
7352 /* cannot use auto_connect_thread_wakeup() because that is allowed to
7353 * fail to wakeup the thread.
7356 pthread_mutex_lock (&_auto_connect_mutex);
7357 g_atomic_int_set (&_ac_thread_active, 0);
7358 pthread_cond_signal (&_auto_connect_cond);
7359 pthread_mutex_unlock (&_auto_connect_mutex);
7362 pthread_join (_auto_connect_thread, &status);
7366 Session::auto_connect_thread (void *arg)
7368 Session *s = static_cast<Session *>(arg);
7369 s->auto_connect_thread_run ();
7375 Session::auto_connect_thread_run ()
7377 pthread_set_name (X_("autoconnect"));
7378 SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7379 PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7380 pthread_mutex_lock (&_auto_connect_mutex);
7381 while (g_atomic_int_get (&_ac_thread_active)) {
7383 if (!_auto_connect_queue.empty ()) {
7384 // Why would we need the process lock ??
7385 // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7386 // graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7387 // All ardour-internal backends use a std::vector xxxAudioBackend::find_port()
7388 // We have control over those, but what does jack do?
7389 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7391 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7392 while (!_auto_connect_queue.empty ()) {
7393 const AutoConnectRequest ar (_auto_connect_queue.front());
7394 _auto_connect_queue.pop ();
7401 if (!actively_recording ()) { // might not be needed,
7402 /* this is only used for updating plugin latencies, the
7403 * graph does not change. so it's safe in general.
7405 * .. update_latency_compensation () entails set_capture_offset()
7406 * which calls Diskstream::set_capture_offset () which
7407 * modifies the capture offset... which can be a proplem
7408 * in "prepare_to_stop"
7410 while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7411 update_latency_compensation ();
7416 // this may call ARDOUR::Port::drop ... jack_port_unregister ()
7417 // jack1 cannot cope with removing ports while processing
7418 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7419 AudioEngine::instance()->clear_pending_port_deletions ();
7422 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7424 pthread_mutex_unlock (&_auto_connect_mutex);
7428 Session::cancel_all_solo ()
7432 get_stripables (sl);
7434 set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7435 clear_all_solo_state (routes.reader());