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/convert.h"
41 #include "pbd/error.h"
42 #include "pbd/file_utils.h"
44 #include "pbd/pthread_utils.h"
45 #include "pbd/search_path.h"
46 #include "pbd/stacktrace.h"
47 #include "pbd/stl_delete.h"
48 #include "pbd/replace_all.h"
49 #include "pbd/unwind.h"
51 #include "ardour/amp.h"
52 #include "ardour/analyser.h"
53 #include "ardour/async_midi_port.h"
54 #include "ardour/audio_buffer.h"
55 #include "ardour/audio_diskstream.h"
56 #include "ardour/audio_port.h"
57 #include "ardour/audio_track.h"
58 #include "ardour/audioengine.h"
59 #include "ardour/audiofilesource.h"
60 #include "ardour/auditioner.h"
61 #include "ardour/boost_debug.h"
62 #include "ardour/buffer_manager.h"
63 #include "ardour/buffer_set.h"
64 #include "ardour/bundle.h"
65 #include "ardour/butler.h"
66 #include "ardour/click.h"
67 #include "ardour/control_protocol_manager.h"
68 #include "ardour/data_type.h"
69 #include "ardour/debug.h"
70 #include "ardour/directory_names.h"
71 #ifdef USE_TRACKS_CODE_FEATURES
72 #include "ardour/engine_state_controller.h"
74 #include "ardour/filename_extensions.h"
75 #include "ardour/gain_control.h"
76 #include "ardour/graph.h"
77 #include "ardour/luabindings.h"
78 #include "ardour/midiport_manager.h"
79 #include "ardour/scene_changer.h"
80 #include "ardour/midi_patch_manager.h"
81 #include "ardour/midi_track.h"
82 #include "ardour/midi_ui.h"
83 #include "ardour/operations.h"
84 #include "ardour/playlist.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/session.h"
98 #include "ardour/session_directory.h"
99 #include "ardour/session_playlists.h"
100 #include "ardour/smf_source.h"
101 #include "ardour/solo_isolate_control.h"
102 #include "ardour/source_factory.h"
103 #include "ardour/speakers.h"
104 #include "ardour/tempo.h"
105 #include "ardour/ticker.h"
106 #include "ardour/track.h"
107 #include "ardour/user_bundle.h"
108 #include "ardour/utils.h"
109 #include "ardour/vca_manager.h"
110 #include "ardour/vca.h"
112 #include "midi++/port.h"
113 #include "midi++/mmc.h"
115 #include "LuaBridge/LuaBridge.h"
117 #include "pbd/i18n.h"
119 #include <glibmm/checksum.h>
128 using namespace ARDOUR;
131 bool Session::_disable_all_loaded_plugins = false;
132 bool Session::_bypass_all_loaded_plugins = false;
133 guint Session::_name_id_counter = 0;
135 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
136 PBD::Signal1<void,std::string> Session::Dialog;
137 PBD::Signal0<int> Session::AskAboutPendingState;
138 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
139 PBD::Signal2<void, framecnt_t, framecnt_t> Session::NotifyAboutSampleRateMismatch;
140 PBD::Signal0<void> Session::SendFeedback;
141 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
143 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
144 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
145 PBD::Signal2<void,std::string, std::string> Session::Exported;
146 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
147 PBD::Signal0<void> Session::Quit;
148 PBD::Signal0<void> Session::FeedbackDetected;
149 PBD::Signal0<void> Session::SuccessfulGraphSort;
150 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
152 const framecnt_t Session::bounce_chunk_size = 8192;
153 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
154 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
156 // seconds should be added after the region exceeds end marker
157 #ifdef USE_TRACKS_CODE_FEATURES
158 const uint32_t Session::session_end_shift = 5;
160 const uint32_t Session::session_end_shift = 0;
163 /** @param snapshot_name Snapshot name, without .ardour suffix */
164 Session::Session (AudioEngine &eng,
165 const string& fullpath,
166 const string& snapshot_name,
167 BusProfile* bus_profile,
169 : playlists (new SessionPlaylists)
171 , process_function (&Session::process_with_events)
172 , _bounce_processing_active (false)
173 , waiting_for_sync_offset (false)
174 , _base_frame_rate (0)
175 , _nominal_frame_rate (0)
176 , _current_frame_rate (0)
177 , transport_sub_state (0)
178 , _record_status (Disabled)
179 , _transport_frame (0)
180 , _session_range_location (0)
181 , _session_range_end_is_free (true)
184 , _transport_speed (0)
185 , _default_transport_speed (1.0)
186 , _last_transport_speed (0)
187 , _target_transport_speed (0.0)
188 , auto_play_legal (false)
189 , _last_slave_transport_frame (0)
190 , maximum_output_latency (0)
191 , _requested_return_frame (-1)
192 , current_block_size (0)
193 , _worst_output_latency (0)
194 , _worst_input_latency (0)
195 , _worst_track_latency (0)
196 , _have_captured (false)
197 , _non_soloed_outs_muted (false)
200 , _solo_isolated_cnt (0)
202 , _was_seamless (Config->get_seamless_loop ())
203 , _under_nsm_control (false)
205 , delta_accumulator_cnt (0)
206 , average_slave_delta (1800) // !!! why 1800 ???
208 , have_first_delta_accumulator (false)
209 , _slave_state (Stopped)
210 , _mtc_active (false)
211 , _ltc_active (false)
212 , post_export_sync (false)
213 , post_export_position (0)
215 , _export_rolling (false)
216 , _realtime_export (false)
217 , _export_preroll (0)
218 , _export_latency (0)
219 , _pre_export_mmc_enabled (false)
220 , _name (snapshot_name)
222 , _send_qf_mtc (false)
223 , _pframes_since_last_mtc (0)
224 , session_midi_feedback (0)
226 , loop_changing (false)
228 , _session_dir (new SessionDirectory (fullpath))
229 , _current_snapshot_name (snapshot_name)
231 , state_was_pending (false)
232 , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
234 , _save_queued (false)
235 , _last_roll_location (0)
236 , _last_roll_or_reversal_location (0)
237 , _last_record_location (0)
238 , pending_locate_roll (false)
239 , pending_locate_frame (0)
240 , pending_locate_flush (false)
241 , pending_abort (false)
242 , pending_auto_loop (false)
243 , _mempool ("Session", 2097152)
244 , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
246 , _butler (new Butler (*this))
247 , _post_transport_work (0)
248 , cumulative_rf_motion (0)
250 , _locations (new Locations (*this))
251 , _ignore_skips_updates (false)
252 , _rt_thread_active (false)
253 , _rt_emit_pending (false)
254 , _ac_thread_active (false)
255 , _latency_recompute_pending (0)
257 , outbound_mtc_timecode_frame (0)
258 , next_quarter_frame_to_send (-1)
259 , _frames_per_timecode_frame (0)
260 , _frames_per_hour (0)
261 , _timecode_frames_per_hour (0)
262 , last_timecode_valid (false)
263 , last_timecode_when (0)
264 , _send_timecode_update (false)
276 , ltc_timecode_offset (0)
277 , ltc_timecode_negative_offset (false)
278 , midi_control_ui (0)
280 , _all_route_group (new RouteGroup (*this, "all"))
281 , routes (new RouteList)
282 , _adding_routes_in_progress (false)
283 , _reconnecting_routes_in_progress (false)
284 , _route_deletion_in_progress (false)
285 , destructive_index (0)
286 , _track_number_decimals(1)
287 , default_fade_steepness (0)
288 , default_fade_msecs (0)
289 , _total_free_4k_blocks (0)
290 , _total_free_4k_blocks_uncertain (false)
291 , no_questions_about_missing_files (false)
294 , _bundles (new BundleList)
295 , _bundle_xml_node (0)
299 , click_emphasis_data (0)
301 , click_emphasis_length (0)
302 , _clicks_cleared (0)
303 , _play_range (false)
304 , _range_selection (-1,-1)
305 , _object_selection (-1,-1)
307 , first_file_data_format_reset (true)
308 , first_file_header_format_reset (true)
309 , have_looped (false)
310 , _have_rec_enabled_track (false)
311 , _have_rec_disabled_track (true)
313 , _suspend_timecode_transmission (0)
314 , _speakers (new Speakers)
315 , ignore_route_processor_changes (false)
320 , _vca_manager (new VCAManager (*this))
324 created_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
326 pthread_mutex_init (&_rt_emit_mutex, 0);
327 pthread_cond_init (&_rt_emit_cond, 0);
329 pthread_mutex_init (&_auto_connect_mutex, 0);
330 pthread_cond_init (&_auto_connect_cond, 0);
332 init_name_id_counter (1); // reset for new sessions, start at 1
333 VCA::set_next_vca_number (1); // reset for new sessions, start at 1
335 pre_engine_init (fullpath);
341 Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
343 #ifdef USE_TRACKS_CODE_FEATURES
344 sr = EngineStateController::instance()->get_current_sample_rate();
346 if (ensure_engine (sr, true)) {
348 throw SessionException (_("Cannot connect to audio/midi engine"));
351 // set samplerate for plugins added early
352 // e.g from templates or MB channelstrip
353 set_block_size (_engine.samples_per_cycle());
354 set_frame_rate (_engine.sample_rate());
356 if (create (mix_template, bus_profile)) {
358 throw SessionException (_("Session initialization failed"));
361 /* if a mix template was provided, then ::create() will
362 * have copied it into the session and we need to load it
363 * so that we have the state ready for ::set_state()
364 * after the engine is started.
366 * Note that we do NOT try to get the sample rate from
367 * the template at this time, though doing so would
368 * be easy if we decided this was an appropriate part
372 if (!mix_template.empty()) {
373 if (load_state (_current_snapshot_name)) {
374 throw SessionException (_("Failed to load template/snapshot state"));
376 store_recent_templates (mix_template);
379 /* load default session properties - if any */
384 if (load_state (_current_snapshot_name)) {
385 throw SessionException (_("Failed to load state"));
388 /* try to get sample rate from XML state so that we
389 * can influence the SR if we set up the audio
394 XMLProperty const * prop;
395 XMLNode const * root (state_tree->root());
396 if ((prop = root->property (X_("sample-rate"))) != 0) {
397 sr = atoi (prop->value());
401 if (ensure_engine (sr, false)) {
403 throw SessionException (_("Cannot connect to audio/midi engine"));
407 if (post_engine_init ()) {
409 throw SessionException (_("Cannot configure audio/midi engine with session parameters"));
412 store_recent_sessions (_name, _path);
414 bool was_dirty = dirty();
416 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
418 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
419 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
422 DirtyChanged (); /* EMIT SIGNAL */
425 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
426 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
428 emit_thread_start ();
429 auto_connect_thread_start ();
431 /* hook us up to the engine since we are now completely constructed */
433 BootMessage (_("Connect to engine"));
435 _engine.set_session (this);
436 _engine.reset_timebase ();
438 #ifdef USE_TRACKS_CODE_FEATURES
440 EngineStateController::instance()->set_session(this);
443 if ( ARDOUR::Profile->get_trx () ) {
445 /* Waves Tracks: fill session with tracks basing on the amount of inputs.
446 * each available input must have corresponding track when session starts.
449 uint32_t how_many (0);
451 std::vector<std::string> inputs;
452 EngineStateController::instance()->get_physical_audio_inputs(inputs);
454 how_many = inputs.size();
456 list<boost::shared_ptr<AudioTrack> > tracks;
458 // Track names after driver
459 if (Config->get_tracks_auto_naming() == NameAfterDriver) {
460 string track_name = "";
461 for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
463 track_name = inputs[i];
464 replace_all (track_name, "system:capture", "");
466 list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
467 tracks.insert(tracks.begin(), single_track.front());
469 } else { // Default track names
470 tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
473 if (tracks.size() != how_many) {
475 throw failed_constructor ();
484 BootMessage (_("Session loading complete"));
496 Session::next_name_id ()
498 return g_atomic_int_add (&_name_id_counter, 1);
502 Session::name_id_counter ()
504 return g_atomic_int_get (&_name_id_counter);
508 Session::init_name_id_counter (guint n)
510 g_atomic_int_set (&_name_id_counter, n);
514 Session::ensure_engine (uint32_t desired_sample_rate, bool isnew)
516 if (_engine.current_backend() == 0) {
517 /* backend is unknown ... */
518 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
519 if (r.get_value_or (-1) != 0) {
522 } else if (!isnew && _engine.running() && _engine.sample_rate () == desired_sample_rate) {
524 } else if (_engine.setup_required()) {
525 /* backend is known, but setup is needed */
526 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
527 if (r.get_value_or (-1) != 0) {
530 } else if (!_engine.running()) {
531 if (_engine.start()) {
536 /* at this point the engine should be running */
538 if (!_engine.running()) {
542 return immediately_post_engine ();
547 Session::immediately_post_engine ()
549 /* Do various initializations that should take place directly after we
550 * know that the engine is running, but before we either create a
551 * session or set state for an existing one.
554 if (how_many_dsp_threads () > 1) {
555 /* For now, only create the graph if we are using >1 DSP threads, as
556 it is a bit slower than the old code with 1 thread.
558 _process_graph.reset (new Graph (*this));
561 /* every time we reconnect, recompute worst case output latencies */
563 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
565 if (synced_to_engine()) {
566 _engine.transport_stop ();
569 if (config.get_jack_time_master()) {
570 _engine.transport_locate (_transport_frame);
575 BootMessage (_("Set up LTC"));
577 BootMessage (_("Set up Click"));
579 BootMessage (_("Set up standard connections"));
583 catch (failed_constructor& err) {
587 /* TODO, connect in different thread. (PortRegisteredOrUnregistered may be in RT context)
589 _engine.PortRegisteredOrUnregistered.connect_same_thread (*this, boost::bind (&Session::setup_bundles, this));
597 vector<void*> debug_pointers;
599 /* if we got to here, leaving pending capture state around
603 remove_pending_capture_state ();
607 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
609 /* stop autoconnecting */
610 auto_connect_thread_terminate ();
612 /* disconnect from any and all signals that we are connected to */
614 Port::PortSignalDrop (); /* EMIT SIGNAL */
617 /* shutdown control surface protocols while we still have ports
618 and the engine to move data to any devices.
621 ControlProtocolManager::instance().drop_protocols ();
623 MIDI::Name::MidiPatchManager::instance().remove_search_path(session_directory().midi_patch_path());
625 _engine.remove_session ();
627 #ifdef USE_TRACKS_CODE_FEATURES
628 EngineStateController::instance()->remove_session();
631 /* deregister all ports - there will be no process or any other
632 * callbacks from the engine any more.
635 Port::PortDrop (); /* EMIT SIGNAL */
639 /* clear history so that no references to objects are held any more */
643 /* clear state tree so that no references to objects are held any more */
648 // unregister all lua functions, drop held references (if any)
650 lua.do_command ("Session = nil");
658 lua.collect_garbage ();
660 /* reset dynamic state version back to default */
661 Stateful::loading_state_version = 0;
663 _butler->drop_references ();
667 delete _all_route_group;
669 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
670 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
674 if (click_data != default_click) {
675 delete [] click_data;
678 if (click_emphasis_data != default_click_emphasis) {
679 delete [] click_emphasis_data;
684 /* need to remove auditioner before monitoring section
685 * otherwise it is re-connected */
688 /* drop references to routes held by the monitoring section
689 * specifically _monitor_out aux/listen references */
690 remove_monitor_section();
692 /* clear out any pending dead wood from RCU managed objects */
697 AudioDiskstream::free_working_buffers();
699 /* tell everyone who is still standing that we're about to die */
702 /* tell everyone to drop references and delete objects as we go */
704 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
705 RegionFactory::delete_all_regions ();
707 /* Do this early so that VCAs no longer hold references to routes */
709 DEBUG_TRACE (DEBUG::Destruction, "delete vcas\n");
712 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
714 /* reset these three references to special routes before we do the usual route delete thing */
716 _master_out.reset ();
717 _monitor_out.reset ();
720 RCUWriter<RouteList> writer (routes);
721 boost::shared_ptr<RouteList> r = writer.get_copy ();
723 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
724 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
725 (*i)->drop_references ();
729 /* writer goes out of scope and updates master */
734 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
735 Glib::Threads::Mutex::Lock lm (source_lock);
736 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
737 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
738 i->second->drop_references ();
744 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
747 emit_thread_terminate ();
749 pthread_cond_destroy (&_rt_emit_cond);
750 pthread_mutex_destroy (&_rt_emit_mutex);
752 pthread_cond_destroy (&_auto_connect_cond);
753 pthread_mutex_destroy (&_auto_connect_mutex);
755 delete _scene_changer; _scene_changer = 0;
756 delete midi_control_ui; midi_control_ui = 0;
758 delete _mmc; _mmc = 0;
759 delete _midi_ports; _midi_ports = 0;
760 delete _locations; _locations = 0;
765 /* clear event queue, the session is gone, nobody is interested in
766 * those anymore, but they do leak memory if not removed
768 while (!immediate_events.empty ()) {
769 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
770 SessionEvent *ev = immediate_events.front ();
771 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Drop event: %1\n", enum_2_string (ev->type)));
772 immediate_events.pop_front ();
776 case SessionEvent::AutoLoop:
777 case SessionEvent::AutoLoopDeclick:
778 case SessionEvent::Skip:
779 case SessionEvent::PunchIn:
780 case SessionEvent::PunchOut:
781 case SessionEvent::StopOnce:
782 case SessionEvent::RangeStop:
783 case SessionEvent::RangeLocate:
787 case SessionEvent::RealTimeOperation:
794 del = del && !_remove_event (ev);
801 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
803 BOOST_SHOW_POINTERS ();
807 Session::setup_ltc ()
811 _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
812 _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
814 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
815 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
818 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
819 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
821 reconnect_ltc_input ();
824 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
825 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
828 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
829 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
831 reconnect_ltc_output ();
834 /* fix up names of LTC ports because we don't want the normal
835 * IO style of NAME/TYPE-{in,out}N
838 _ltc_input->nth (0)->set_name (X_("LTC-in"));
839 _ltc_output->nth (0)->set_name (X_("LTC-out"));
843 Session::setup_click ()
847 boost::shared_ptr<AutomationList> gl (new AutomationList (Evoral::Parameter (GainAutomation)));
848 boost::shared_ptr<GainControl> gain_control = boost::shared_ptr<GainControl> (new GainControl (*this, Evoral::Parameter(GainAutomation), gl));
850 _click_io.reset (new ClickIO (*this, X_("Click")));
851 _click_gain.reset (new Amp (*this, _("Fader"), gain_control, true));
852 _click_gain->activate ();
854 setup_click_state (state_tree->root());
856 setup_click_state (0);
861 Session::setup_click_state (const XMLNode* node)
863 const XMLNode* child = 0;
865 if (node && (child = find_named_node (*node, "Click")) != 0) {
867 /* existing state for Click */
870 if (Stateful::loading_state_version < 3000) {
871 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
873 const XMLNodeList& children (child->children());
874 XMLNodeList::const_iterator i = children.begin();
875 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
877 if (i != children.end()) {
878 c = _click_gain->set_state (**i, Stateful::loading_state_version);
884 _clicking = Config->get_clicking ();
888 error << _("could not setup Click I/O") << endmsg;
895 /* default state for Click: dual-mono to first 2 physical outputs */
898 _engine.get_physical_outputs (DataType::AUDIO, outs);
900 for (uint32_t physport = 0; physport < 2; ++physport) {
901 if (outs.size() > physport) {
902 if (_click_io->add_port (outs[physport], this)) {
903 // relax, even though its an error
908 if (_click_io->n_ports () > ChanCount::ZERO) {
909 _clicking = Config->get_clicking ();
915 Session::setup_bundles ()
919 RCUWriter<BundleList> writer (_bundles);
920 boost::shared_ptr<BundleList> b = writer.get_copy ();
921 for (BundleList::iterator i = b->begin(); i != b->end();) {
922 if (boost::dynamic_pointer_cast<UserBundle>(*i)) {
930 vector<string> inputs[DataType::num_types];
931 vector<string> outputs[DataType::num_types];
932 for (uint32_t i = 0; i < DataType::num_types; ++i) {
933 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
934 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
937 /* Create a set of Bundle objects that map
938 to the physical I/O currently available. We create both
939 mono and stereo bundles, so that the common cases of mono
940 and stereo tracks get bundles to put in their mixer strip
941 in / out menus. There may be a nicer way of achieving that;
942 it doesn't really scale that well to higher channel counts
945 /* mono output bundles */
947 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
949 std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
951 snprintf (buf, sizeof (buf), _("out %s"), pn.c_str());
953 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
956 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
957 c->add_channel (_("mono"), DataType::AUDIO);
958 c->set_port (0, outputs[DataType::AUDIO][np]);
960 add_bundle (c, false);
963 /* stereo output bundles */
965 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
966 if (np + 1 < outputs[DataType::AUDIO].size()) {
968 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
969 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
970 c->add_channel (_("L"), DataType::AUDIO);
971 c->set_port (0, outputs[DataType::AUDIO][np]);
972 c->add_channel (_("R"), DataType::AUDIO);
973 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
975 add_bundle (c, false);
979 /* mono input bundles */
981 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
983 std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
985 snprintf (buf, sizeof (buf), _("in %s"), pn.c_str());
987 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
990 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
991 c->add_channel (_("mono"), DataType::AUDIO);
992 c->set_port (0, inputs[DataType::AUDIO][np]);
994 add_bundle (c, false);
997 /* stereo input bundles */
999 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
1000 if (np + 1 < inputs[DataType::AUDIO].size()) {
1002 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
1004 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
1005 c->add_channel (_("L"), DataType::AUDIO);
1006 c->set_port (0, inputs[DataType::AUDIO][np]);
1007 c->add_channel (_("R"), DataType::AUDIO);
1008 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
1010 add_bundle (c, false);
1014 /* MIDI input bundles */
1016 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
1017 string n = inputs[DataType::MIDI][np];
1018 std::string pn = _engine.get_pretty_name_by_name (n);
1022 boost::erase_first (n, X_("alsa_pcm:"));
1024 boost::shared_ptr<Bundle> c (new Bundle (n, false));
1025 c->add_channel ("", DataType::MIDI);
1026 c->set_port (0, inputs[DataType::MIDI][np]);
1027 add_bundle (c, false);
1030 /* MIDI output bundles */
1032 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
1033 string n = outputs[DataType::MIDI][np];
1034 std::string pn = _engine.get_pretty_name_by_name (n);
1038 boost::erase_first (n, X_("alsa_pcm:"));
1040 boost::shared_ptr<Bundle> c (new Bundle (n, true));
1041 c->add_channel ("", DataType::MIDI);
1042 c->set_port (0, outputs[DataType::MIDI][np]);
1043 add_bundle (c, false);
1046 // we trust the backend to only calls us if there's a change
1047 BundleAddedOrRemoved (); /* EMIT SIGNAL */
1051 Session::auto_connect_master_bus ()
1053 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
1057 // Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
1058 // In this case it means "Multi Out" output mode
1059 if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
1063 /* if requested auto-connect the outputs to the first N physical ports.
1066 uint32_t limit = _master_out->n_outputs().n_total();
1067 vector<string> outputs[DataType::num_types];
1069 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1070 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1073 for (uint32_t n = 0; n < limit; ++n) {
1074 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
1076 if (outputs[p->type()].size() > n) {
1077 connect_to = outputs[p->type()][n];
1080 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
1081 if (_master_out->output()->connect (p, connect_to, this)) {
1082 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
1091 Session::remove_monitor_section ()
1093 if (!_monitor_out || Profile->get_trx()) {
1097 /* force reversion to Solo-In-Place */
1098 Config->set_solo_control_is_listen_control (false);
1100 /* if we are auditioning, cancel it ... this is a workaround
1101 to a problem (auditioning does not execute the process graph,
1102 which is needed to remove routes when using >1 core for processing)
1107 /* Hold process lock while doing this so that we don't hear bits and
1108 * pieces of audio as we work on each route.
1111 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1113 /* Connect tracks to monitor section. Note that in an
1114 existing session, the internal sends will already exist, but we want the
1115 routes to notice that they connect to the control out specifically.
1119 boost::shared_ptr<RouteList> r = routes.reader ();
1120 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1122 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
1124 if ((*x)->is_monitor()) {
1126 } else if ((*x)->is_master()) {
1129 (*x)->remove_aux_or_listen (_monitor_out);
1134 remove_route (_monitor_out);
1135 if (_state_of_the_state & Deletion) {
1139 auto_connect_master_bus ();
1142 auditioner->connect ();
1145 Config->ParameterChanged ("use-monitor-bus");
1149 Session::add_monitor_section ()
1153 if (_monitor_out || !_master_out || Profile->get_trx()) {
1157 boost::shared_ptr<Route> r (new Route (*this, _("Monitor"), PresentationInfo::MonitorOut, DataType::AUDIO));
1163 BOOST_MARK_ROUTE(r);
1166 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1167 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1168 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1170 error << _("Cannot create monitor section. 'Monitor' Port name is not unique.") << endmsg;
1175 add_routes (rl, false, false, false, 0);
1177 assert (_monitor_out);
1179 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
1180 are undefined, at best.
1183 uint32_t limit = _monitor_out->n_inputs().n_audio();
1187 /* connect the inputs to the master bus outputs. this
1188 * represents a separate data feed from the internal sends from
1189 * each route. as of jan 2011, it allows the monitor section to
1190 * conditionally ignore either the internal sends or the normal
1191 * input feed, but we should really find a better way to do
1195 _master_out->output()->disconnect (this);
1197 for (uint32_t n = 0; n < limit; ++n) {
1198 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1199 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1202 string connect_to = o->name();
1203 if (_monitor_out->input()->connect (p, connect_to, this)) {
1204 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1212 /* if monitor section is not connected, connect it to physical outs
1215 if ((Config->get_auto_connect_standard_busses () || Profile->get_mixbus ()) && !_monitor_out->output()->connected ()) {
1217 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1219 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1222 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1224 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1225 Config->get_monitor_bus_preferred_bundle())
1231 /* Monitor bus is audio only */
1233 vector<string> outputs[DataType::num_types];
1235 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1236 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1239 uint32_t mod = outputs[DataType::AUDIO].size();
1240 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1244 for (uint32_t n = 0; n < limit; ++n) {
1246 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1248 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1249 connect_to = outputs[DataType::AUDIO][n % mod];
1252 if (!connect_to.empty()) {
1253 if (_monitor_out->output()->connect (p, connect_to, this)) {
1254 error << string_compose (
1255 _("cannot connect control output %1 to %2"),
1266 /* Hold process lock while doing this so that we don't hear bits and
1267 * pieces of audio as we work on each route.
1270 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1272 /* Connect tracks to monitor section. Note that in an
1273 existing session, the internal sends will already exist, but we want the
1274 routes to notice that they connect to the control out specifically.
1278 boost::shared_ptr<RouteList> rls = routes.reader ();
1280 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1282 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1284 if ((*x)->is_monitor()) {
1286 } else if ((*x)->is_master()) {
1289 (*x)->enable_monitor_send ();
1294 auditioner->connect ();
1296 Config->ParameterChanged ("use-monitor-bus");
1300 Session::reset_monitor_section ()
1302 /* Process lock should be held by the caller.*/
1304 if (!_monitor_out || Profile->get_trx()) {
1308 uint32_t limit = _master_out->n_outputs().n_audio();
1310 /* connect the inputs to the master bus outputs. this
1311 * represents a separate data feed from the internal sends from
1312 * each route. as of jan 2011, it allows the monitor section to
1313 * conditionally ignore either the internal sends or the normal
1314 * input feed, but we should really find a better way to do
1318 _master_out->output()->disconnect (this);
1319 _monitor_out->output()->disconnect (this);
1321 // monitor section follow master bus - except midi
1322 ChanCount mon_chn (_master_out->output()->n_ports());
1323 mon_chn.set_midi (0);
1325 _monitor_out->input()->ensure_io (mon_chn, false, this);
1326 _monitor_out->output()->ensure_io (mon_chn, false, this);
1328 for (uint32_t n = 0; n < limit; ++n) {
1329 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1330 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1333 string connect_to = o->name();
1334 if (_monitor_out->input()->connect (p, connect_to, this)) {
1335 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1342 /* connect monitor section to physical outs
1345 if (Config->get_auto_connect_standard_busses()) {
1347 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1349 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1352 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1354 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1355 Config->get_monitor_bus_preferred_bundle())
1361 /* Monitor bus is audio only */
1363 vector<string> outputs[DataType::num_types];
1365 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1366 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1369 uint32_t mod = outputs[DataType::AUDIO].size();
1370 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1374 for (uint32_t n = 0; n < limit; ++n) {
1376 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1378 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1379 connect_to = outputs[DataType::AUDIO][n % mod];
1382 if (!connect_to.empty()) {
1383 if (_monitor_out->output()->connect (p, connect_to, this)) {
1384 error << string_compose (
1385 _("cannot connect control output %1 to %2"),
1396 /* Connect tracks to monitor section. Note that in an
1397 existing session, the internal sends will already exist, but we want the
1398 routes to notice that they connect to the control out specifically.
1402 boost::shared_ptr<RouteList> rls = routes.reader ();
1404 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1406 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1408 if ((*x)->is_monitor()) {
1410 } else if ((*x)->is_master()) {
1413 (*x)->enable_monitor_send ();
1419 Session::hookup_io ()
1421 /* stop graph reordering notifications from
1422 causing resorts, etc.
1425 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1429 /* we delay creating the auditioner till now because
1430 it makes its own connections to ports.
1434 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1436 throw failed_constructor ();
1438 a->use_new_diskstream ();
1442 catch (failed_constructor& err) {
1443 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1447 /* load bundles, which we may have postponed earlier on */
1448 if (_bundle_xml_node) {
1449 load_bundles (*_bundle_xml_node);
1450 delete _bundle_xml_node;
1453 /* Tell all IO objects to connect themselves together */
1455 IO::enable_connecting ();
1457 /* Now tell all "floating" ports to connect to whatever
1458 they should be connected to.
1461 AudioEngine::instance()->reconnect_ports ();
1463 /* Anyone who cares about input state, wake up and do something */
1465 IOConnectionsComplete (); /* EMIT SIGNAL */
1467 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1469 /* now handle the whole enchilada as if it was one
1470 graph reorder event.
1475 /* update the full solo state, which can't be
1476 correctly determined on a per-route basis, but
1477 needs the global overview that only the session
1481 update_route_solo_state ();
1485 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1487 boost::shared_ptr<Track> track = wp.lock ();
1492 boost::shared_ptr<Playlist> playlist;
1494 if ((playlist = track->playlist()) != 0) {
1495 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1496 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1497 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1502 Session::record_enabling_legal () const
1504 /* this used to be in here, but survey says.... we don't need to restrict it */
1505 // if (record_status() == Recording) {
1509 if (Config->get_all_safe()) {
1516 Session::set_track_monitor_input_status (bool yn)
1518 boost::shared_ptr<RouteList> rl = routes.reader ();
1519 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1520 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1521 if (tr && tr->rec_enable_control()->get_value()) {
1522 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1523 tr->request_input_monitoring (yn);
1529 Session::auto_punch_start_changed (Location* location)
1531 replace_event (SessionEvent::PunchIn, location->start());
1533 if (get_record_enabled() && config.get_punch_in()) {
1534 /* capture start has been changed, so save new pending state */
1535 save_state ("", true);
1540 Session::auto_punch_end_changed (Location* location)
1542 framepos_t when_to_stop = location->end();
1543 // when_to_stop += _worst_output_latency + _worst_input_latency;
1544 replace_event (SessionEvent::PunchOut, when_to_stop);
1548 Session::auto_punch_changed (Location* location)
1550 framepos_t when_to_stop = location->end();
1552 replace_event (SessionEvent::PunchIn, location->start());
1553 //when_to_stop += _worst_output_latency + _worst_input_latency;
1554 replace_event (SessionEvent::PunchOut, when_to_stop);
1557 /** @param loc A loop location.
1558 * @param pos Filled in with the start time of the required fade-out (in session frames).
1559 * @param length Filled in with the length of the required fade-out.
1562 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1564 pos = max (loc->start(), loc->end() - 64);
1565 length = loc->end() - pos;
1569 Session::auto_loop_changed (Location* location)
1571 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1574 auto_loop_declick_range (location, dcp, dcl);
1576 if (transport_rolling() && play_loop) {
1578 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1580 // if (_transport_frame > location->end()) {
1582 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1583 // relocate to beginning of loop
1584 clear_events (SessionEvent::LocateRoll);
1586 request_locate (location->start(), true);
1589 else if (Config->get_seamless_loop() && !loop_changing) {
1591 // schedule a locate-roll to refill the diskstreams at the
1592 // previous loop end
1593 loop_changing = true;
1595 if (location->end() > last_loopend) {
1596 clear_events (SessionEvent::LocateRoll);
1597 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1603 clear_events (SessionEvent::AutoLoopDeclick);
1604 clear_events (SessionEvent::AutoLoop);
1607 /* possibly move playhead if not rolling; if we are rolling we'll move
1608 to the loop start on stop if that is appropriate.
1613 if (!transport_rolling() && select_playhead_priority_target (pos)) {
1614 if (pos == location->start()) {
1615 request_locate (pos);
1620 last_loopend = location->end();
1625 Session::set_auto_punch_location (Location* location)
1629 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1630 punch_connections.drop_connections();
1631 existing->set_auto_punch (false, this);
1632 remove_event (existing->start(), SessionEvent::PunchIn);
1633 clear_events (SessionEvent::PunchOut);
1634 auto_punch_location_changed (0);
1639 if (location == 0) {
1643 if (location->end() <= location->start()) {
1644 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1648 punch_connections.drop_connections ();
1650 location->StartChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, location));
1651 location->EndChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, location));
1652 location->Changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, location));
1654 location->set_auto_punch (true, this);
1656 auto_punch_changed (location);
1658 auto_punch_location_changed (location);
1662 Session::set_session_extents (framepos_t start, framepos_t end)
1665 if ((existing = _locations->session_range_location()) == 0) {
1666 //if there is no existing session, we need to make a new session location (should never happen)
1667 existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
1671 error << _("Session: you can't use that location for session start/end)") << endmsg;
1675 existing->set( start, end );
1681 Session::set_auto_loop_location (Location* location)
1685 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1686 loop_connections.drop_connections ();
1687 existing->set_auto_loop (false, this);
1688 remove_event (existing->end(), SessionEvent::AutoLoop);
1691 auto_loop_declick_range (existing, dcp, dcl);
1692 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1693 auto_loop_location_changed (0);
1698 if (location == 0) {
1702 if (location->end() <= location->start()) {
1703 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1707 last_loopend = location->end();
1709 loop_connections.drop_connections ();
1711 location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1712 location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1713 location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1714 location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1716 location->set_auto_loop (true, this);
1718 if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
1719 // set all tracks to use internal looping
1720 boost::shared_ptr<RouteList> rl = routes.reader ();
1721 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1722 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1723 if (tr && !tr->hidden()) {
1724 tr->set_loop (location);
1729 /* take care of our stuff first */
1731 auto_loop_changed (location);
1733 /* now tell everyone else */
1735 auto_loop_location_changed (location);
1739 Session::update_marks (Location*)
1745 Session::update_skips (Location* loc, bool consolidate)
1747 if (_ignore_skips_updates) {
1751 Locations::LocationList skips;
1754 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1755 consolidate_skips (loc);
1758 sync_locations_to_skips ();
1764 Session::consolidate_skips (Location* loc)
1766 Locations::LocationList all_locations = _locations->list ();
1768 for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1770 if (!(*l)->is_skip ()) {
1775 /* don't test against self */
1782 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1783 case Evoral::OverlapInternal:
1784 case Evoral::OverlapExternal:
1785 case Evoral::OverlapStart:
1786 case Evoral::OverlapEnd:
1787 /* adjust new location to cover existing one */
1788 loc->set_start (min (loc->start(), (*l)->start()));
1789 loc->set_end (max (loc->end(), (*l)->end()));
1790 /* we don't need this one any more */
1791 _locations->remove (*l);
1792 /* the location has been deleted, so remove reference to it in our local list */
1793 l = all_locations.erase (l);
1796 case Evoral::OverlapNone:
1804 Session::sync_locations_to_skips ()
1806 /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1807 * Session::_sync_locations_to_skips() from the audioengine thread.
1809 clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1813 Session::_sync_locations_to_skips ()
1815 /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1817 Locations::LocationList const & locs (_locations->list());
1819 for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1821 Location* location = *i;
1823 if (location->is_skip() && location->is_skipping()) {
1824 SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1832 Session::location_added (Location *location)
1834 if (location->is_auto_punch()) {
1835 set_auto_punch_location (location);
1838 if (location->is_auto_loop()) {
1839 set_auto_loop_location (location);
1842 if (location->is_session_range()) {
1843 /* no need for any signal handling or event setting with the session range,
1844 because we keep a direct reference to it and use its start/end directly.
1846 _session_range_location = location;
1849 if (location->is_mark()) {
1850 /* listen for per-location signals that require us to do any * global updates for marks */
1852 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1853 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1854 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1855 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1858 if (location->is_skip()) {
1859 /* listen for per-location signals that require us to update skip-locate events */
1861 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1862 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1863 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1864 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
1866 update_skips (location, true);
1873 Session::location_removed (Location *location)
1875 if (location->is_auto_loop()) {
1876 set_auto_loop_location (0);
1877 set_track_loop (false);
1880 if (location->is_auto_punch()) {
1881 set_auto_punch_location (0);
1884 if (location->is_session_range()) {
1885 /* this is never supposed to happen */
1886 error << _("programming error: session range removed!") << endl;
1889 if (location->is_skip()) {
1891 update_skips (location, false);
1898 Session::locations_changed ()
1900 _locations->apply (*this, &Session::_locations_changed);
1904 Session::_locations_changed (const Locations::LocationList& locations)
1906 /* There was some mass-change in the Locations object.
1908 We might be re-adding a location here but it doesn't actually matter
1909 for all the locations that the Session takes an interest in.
1913 PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
1914 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1915 location_added (*i);
1919 update_skips (NULL, false);
1923 Session::enable_record ()
1925 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1926 /* no recording at anything except normal speed */
1931 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1933 if (rs == Recording) {
1937 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1939 _last_record_location = _transport_frame;
1940 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1942 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1943 set_track_monitor_input_status (true);
1946 RecordStateChanged ();
1953 Session::set_all_tracks_record_enabled (bool enable )
1955 boost::shared_ptr<RouteList> rl = routes.reader();
1956 set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), enable, Controllable::NoGroup);
1960 Session::disable_record (bool rt_context, bool force)
1964 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1966 if (!Config->get_latched_record_enable () || force) {
1967 g_atomic_int_set (&_record_status, Disabled);
1968 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1970 if (rs == Recording) {
1971 g_atomic_int_set (&_record_status, Enabled);
1975 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1976 set_track_monitor_input_status (false);
1979 RecordStateChanged (); /* emit signal */
1982 remove_pending_capture_state ();
1988 Session::step_back_from_record ()
1990 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1992 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1993 set_track_monitor_input_status (false);
1996 RecordStateChanged (); /* emit signal */
2001 Session::maybe_enable_record ()
2003 if (_step_editors > 0) {
2007 g_atomic_int_set (&_record_status, Enabled);
2009 /* This function is currently called from somewhere other than an RT thread.
2010 This save_state() call therefore doesn't impact anything. Doing it here
2011 means that we save pending state of which sources the next record will use,
2012 which gives us some chance of recovering from a crash during the record.
2015 save_state ("", true);
2017 if (_transport_speed) {
2018 if (!config.get_punch_in()) {
2022 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
2023 RecordStateChanged (); /* EMIT SIGNAL */
2030 Session::audible_frame () const
2036 offset = worst_playback_latency ();
2038 if (synced_to_engine()) {
2039 /* Note: this is basically just sync-to-JACK */
2040 tf = _engine.transport_frame();
2042 tf = _transport_frame;
2047 if (!non_realtime_work_pending()) {
2051 /* Check to see if we have passed the first guaranteed
2052 audible frame past our last start position. if not,
2053 return that last start point because in terms
2054 of audible frames, we have not moved yet.
2056 `Start position' in this context means the time we last
2057 either started, located, or changed transport direction.
2060 if (_transport_speed > 0.0f) {
2062 if (!play_loop || !have_looped) {
2063 if (tf < _last_roll_or_reversal_location + offset) {
2064 return _last_roll_or_reversal_location;
2072 } else if (_transport_speed < 0.0f) {
2074 /* XXX wot? no backward looping? */
2076 if (tf > _last_roll_or_reversal_location - offset) {
2077 return _last_roll_or_reversal_location;
2089 Session::set_frame_rate (framecnt_t frames_per_second)
2091 /** \fn void Session::set_frame_size(framecnt_t)
2092 the AudioEngine object that calls this guarantees
2093 that it will not be called while we are also in
2094 ::process(). Its fine to do things that block
2098 if (_base_frame_rate == 0) {
2099 _base_frame_rate = frames_per_second;
2101 else if (_base_frame_rate != frames_per_second && frames_per_second != _nominal_frame_rate) {
2102 NotifyAboutSampleRateMismatch (_base_frame_rate, frames_per_second);
2104 _nominal_frame_rate = frames_per_second;
2109 reset_write_sources (false);
2111 // XXX we need some equivalent to this, somehow
2112 // SndFileSource::setup_standard_crossfades (frames_per_second);
2116 /* XXX need to reset/reinstantiate all LADSPA plugins */
2120 Session::set_block_size (pframes_t nframes)
2122 /* the AudioEngine guarantees
2123 that it will not be called while we are also in
2124 ::process(). It is therefore fine to do things that block
2129 current_block_size = nframes;
2133 boost::shared_ptr<RouteList> r = routes.reader ();
2135 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2136 (*i)->set_block_size (nframes);
2139 boost::shared_ptr<RouteList> rl = routes.reader ();
2140 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2141 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2143 tr->set_block_size (nframes);
2147 set_worst_io_latencies ();
2153 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2155 boost::shared_ptr<Route> r2;
2157 if (r1->feeds (rbase) && rbase->feeds (r1)) {
2158 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2162 /* make a copy of the existing list of routes that feed r1 */
2164 Route::FedBy existing (r1->fed_by());
2166 /* for each route that feeds r1, recurse, marking it as feeding
2170 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2171 if (!(r2 = i->r.lock ())) {
2172 /* (*i) went away, ignore it */
2176 /* r2 is a route that feeds r1 which somehow feeds base. mark
2177 base as being fed by r2
2180 rbase->add_fed_by (r2, i->sends_only);
2184 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2188 if (r1->feeds (r2) && r2->feeds (r1)) {
2192 /* now recurse, so that we can mark base as being fed by
2193 all routes that feed r2
2196 trace_terminal (r2, rbase);
2203 Session::resort_routes ()
2205 /* don't do anything here with signals emitted
2206 by Routes during initial setup or while we
2207 are being destroyed.
2210 if (_state_of_the_state & (InitialConnecting | Deletion)) {
2214 if (_route_deletion_in_progress) {
2219 RCUWriter<RouteList> writer (routes);
2220 boost::shared_ptr<RouteList> r = writer.get_copy ();
2221 resort_routes_using (r);
2222 /* writer goes out of scope and forces update */
2226 if (DEBUG_ENABLED(DEBUG::Graph)) {
2227 boost::shared_ptr<RouteList> rl = routes.reader ();
2228 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2229 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2231 const Route::FedBy& fb ((*i)->fed_by());
2233 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2234 boost::shared_ptr<Route> sf = f->r.lock();
2236 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2245 /** This is called whenever we need to rebuild the graph of how we will process
2247 * @param r List of routes, in any order.
2251 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2253 /* We are going to build a directed graph of our routes;
2254 this is where the edges of that graph are put.
2259 /* Go through all routes doing two things:
2261 * 1. Collect the edges of the route graph. Each of these edges
2262 * is a pair of routes, one of which directly feeds the other
2263 * either by a JACK connection or by an internal send.
2265 * 2. Begin the process of making routes aware of which other
2266 * routes directly or indirectly feed them. This information
2267 * is used by the solo code.
2270 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2272 /* Clear out the route's list of direct or indirect feeds */
2273 (*i)->clear_fed_by ();
2275 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2277 bool via_sends_only;
2279 /* See if this *j feeds *i according to the current state of the JACK
2280 connections and internal sends.
2282 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2283 /* add the edge to the graph (part #1) */
2284 edges.add (*j, *i, via_sends_only);
2285 /* tell the route (for part #2) */
2286 (*i)->add_fed_by (*j, via_sends_only);
2291 /* Attempt a topological sort of the route graph */
2292 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2294 if (sorted_routes) {
2295 /* We got a satisfactory topological sort, so there is no feedback;
2298 Note: the process graph rechain does not require a
2299 topologically-sorted list, but hey ho.
2301 if (_process_graph) {
2302 _process_graph->rechain (sorted_routes, edges);
2305 _current_route_graph = edges;
2307 /* Complete the building of the routes' lists of what directly
2308 or indirectly feeds them.
2310 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2311 trace_terminal (*i, *i);
2314 *r = *sorted_routes;
2317 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2318 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2319 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
2323 SuccessfulGraphSort (); /* EMIT SIGNAL */
2326 /* The topological sort failed, so we have a problem. Tell everyone
2327 and stick to the old graph; this will continue to be processed, so
2328 until the feedback is fixed, what is played back will not quite
2329 reflect what is actually connected. Note also that we do not
2330 do trace_terminal here, as it would fail due to an endless recursion,
2331 so the solo code will think that everything is still connected
2335 FeedbackDetected (); /* EMIT SIGNAL */
2340 /** Find a route name starting with \a base, maybe followed by the
2341 * lowest \a id. \a id will always be added if \a definitely_add_number
2342 * is true on entry; otherwise it will only be added if required
2343 * to make the name unique.
2345 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2346 * The available route name with the lowest ID will be used, and \a id
2347 * will be set to the ID.
2349 * \return false if a route name could not be found, and \a track_name
2350 * and \a id do not reflect a free route name.
2353 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2355 /* the base may conflict with ports that do not belong to existing
2356 routes, but hidden objects like the click track. So check port names
2357 before anything else.
2360 for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2361 if (base == *reserved) {
2362 /* Check if this reserved name already exists, and if
2363 so, disallow it without a numeric suffix.
2365 if (route_by_name (*reserved)) {
2366 definitely_add_number = true;
2375 if (!definitely_add_number && route_by_name (base) == 0) {
2376 /* juse use the base */
2382 name = string_compose ("%1 %2", base, id);
2384 if (route_by_name (name) == 0) {
2390 } while (id < (UINT_MAX-1));
2395 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2397 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2399 in = ChanCount::ZERO;
2400 out = ChanCount::ZERO;
2402 boost::shared_ptr<RouteList> r = routes.reader ();
2404 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2405 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2406 if (tr && !tr->is_auditioner()) {
2407 in += tr->n_inputs();
2408 out += tr->n_outputs();
2414 Session::default_track_name_pattern (DataType t)
2417 case DataType::AUDIO:
2418 if (Profile->get_trx()) {
2425 case DataType::MIDI:
2432 /** Caller must not hold process lock
2433 * @param name_template string to use for the start of the name, or "" to use "MIDI".
2434 * @param instrument plugin info for the instrument to insert pre-fader, if any
2436 list<boost::shared_ptr<MidiTrack> >
2437 Session::new_midi_track (const ChanCount& input, const ChanCount& output,
2438 boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2439 RouteGroup* route_group, uint32_t how_many, string name_template, PresentationInfo::order_t order,
2443 uint32_t track_id = 0;
2445 RouteList new_routes;
2446 list<boost::shared_ptr<MidiTrack> > ret;
2448 const string name_pattern = default_track_name_pattern (DataType::MIDI);
2449 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2452 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2453 error << "cannot find name for new midi track" << endmsg;
2457 boost::shared_ptr<MidiTrack> track;
2460 track.reset (new MidiTrack (*this, track_name, mode));
2462 if (track->init ()) {
2466 if (Profile->get_mixbus ()) {
2467 track->set_strict_io (true);
2470 track->use_new_diskstream();
2472 BOOST_MARK_TRACK (track);
2475 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2476 if (track->input()->ensure_io (input, false, this)) {
2477 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2481 if (track->output()->ensure_io (output, false, this)) {
2482 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2487 track->non_realtime_input_change();
2490 route_group->add (track);
2493 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2495 new_routes.push_back (track);
2496 ret.push_back (track);
2499 catch (failed_constructor &err) {
2500 error << _("Session: could not create new midi track.") << endmsg;
2504 catch (AudioEngine::PortRegistrationFailure& pfe) {
2506 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;
2514 if (!new_routes.empty()) {
2515 StateProtector sp (this);
2516 if (Profile->get_trx()) {
2517 add_routes (new_routes, false, false, false, order);
2519 add_routes (new_routes, true, true, false, order);
2523 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2524 PluginPtr plugin = instrument->load (*this);
2526 plugin->load_preset (*pset);
2528 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2529 (*r)->add_processor (p, PreFader);
2539 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord* pset,
2540 PresentationInfo::Flag flag, PresentationInfo::order_t order)
2543 uint32_t bus_id = 0;
2547 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2550 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2551 error << "cannot find name for new midi bus" << endmsg;
2556 boost::shared_ptr<Route> bus (new Route (*this, bus_name, flag, DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2562 if (Profile->get_mixbus ()) {
2563 bus->set_strict_io (true);
2566 BOOST_MARK_ROUTE(bus);
2569 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2571 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2572 error << _("cannot configure new midi bus input") << endmsg;
2577 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2578 error << _("cannot configure new midi bus output") << endmsg;
2584 route_group->add (bus);
2587 bus->add_internal_return ();
2588 ret.push_back (bus);
2591 catch (failed_constructor &err) {
2592 error << _("Session: could not create new audio route.") << endmsg;
2596 catch (AudioEngine::PortRegistrationFailure& pfe) {
2597 error << pfe.what() << endmsg;
2607 StateProtector sp (this);
2608 add_routes (ret, false, false, false, order);
2611 for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2612 PluginPtr plugin = instrument->load (*this);
2614 plugin->load_preset (*pset);
2616 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2617 (*r)->add_processor (p, PreFader);
2628 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2630 boost::shared_ptr<Route> midi_track (wmt.lock());
2636 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2638 if (change.after.n_audio() <= change.before.n_audio()) {
2642 /* new audio ports: make sure the audio goes somewhere useful,
2643 * unless the user has no-auto-connect selected.
2645 * The existing ChanCounts don't matter for this call as they are only
2646 * to do with matching input and output indices, and we are only changing
2649 auto_connect_route (midi_track, false, ChanCount(), change.before);
2653 #ifdef USE_TRACKS_CODE_FEATURES
2656 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2658 return route1->remote_control_id() < route2->remote_control_id();
2662 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2664 // it is not allowed to perform connection
2665 if (!IO::connecting_legal) {
2669 // if we are deleting routes we will call this once at the end
2670 if (_route_deletion_in_progress) {
2674 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2680 // We need to disconnect the route's inputs and outputs first
2681 // basing on autoconnect configuration
2682 bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2683 bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2685 ChanCount existing_inputs;
2686 ChanCount existing_outputs;
2687 count_existing_track_channels (existing_inputs, existing_outputs);
2689 //ChanCount inputs = ChanCount::ZERO;
2690 //ChanCount outputs = ChanCount::ZERO;
2692 RouteList existing_routes = *routes.reader ();
2693 existing_routes.sort (compare_routes_by_remote_id);
2696 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2698 vector<string> physinputs;
2699 vector<string> physoutputs;
2701 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2702 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2704 uint32_t input_n = 0;
2705 uint32_t output_n = 0;
2706 RouteList::iterator rIter = existing_routes.begin();
2707 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2708 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2709 for (; rIter != existing_routes.end(); ++rIter) {
2710 if (*rIter == _master_out || *rIter == _monitor_out ) {
2714 if (current_output_auto_connection == AutoConnectPhysical) {
2715 (*rIter)->amp()->deactivate();
2716 } else if (current_output_auto_connection == AutoConnectMaster) {
2717 (*rIter)->amp()->activate();
2720 if (reconnectIputs) {
2721 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2723 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2725 if (current_input_auto_connection & AutoConnectPhysical) {
2727 if ( input_n == physinputs.size() ) {
2731 string port = physinputs[input_n];
2733 if (port.empty() ) {
2734 error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2737 //GZ: check this; could be heavy
2738 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2744 if (reconnectOutputs) {
2746 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2747 if (current_output_auto_connection & AutoConnectPhysical) {
2749 //GZ: check this; could be heavy
2750 (*rIter)->output()->disconnect (this);
2751 size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2753 //GZ: check this; could be heavy
2754 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2756 } else if (current_output_auto_connection & AutoConnectMaster){
2758 if (!reconnect_master) {
2762 //GZ: check this; could be heavy
2763 (*rIter)->output()->disconnect (this);
2766 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2767 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2769 error << error << "Master bus is not available" << endmsg;
2774 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2775 if (current_output_auto_connection & AutoConnectPhysical) {
2777 if ( output_n == physoutputs.size() ) {
2781 string port = physoutputs[output_n];
2783 if (port.empty() ) {
2784 error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2787 //GZ: check this; could be heavy
2788 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2791 } else if (current_output_auto_connection & AutoConnectMaster) {
2793 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2797 // connect to master bus
2798 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2800 if (port.empty() ) {
2801 error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2805 //GZ: check this; could be heavy
2806 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2813 _master_out->output()->disconnect (this);
2814 auto_connect_master_bus ();
2819 session_routes_reconnected (); /* EMIT SIGNAL */
2823 Session::reconnect_midi_scene_ports(bool inputs)
2827 boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2829 scene_in_ptr->disconnect_all ();
2831 std::vector<EngineStateController::MidiPortState> midi_port_states;
2832 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2834 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2836 for (; state_iter != midi_port_states.end(); ++state_iter) {
2837 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2838 scene_in_ptr->connect (state_iter->name);
2845 boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2847 if (scene_out_ptr ) {
2848 scene_out_ptr->disconnect_all ();
2850 std::vector<EngineStateController::MidiPortState> midi_port_states;
2851 EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2853 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2855 for (; state_iter != midi_port_states.end(); ++state_iter) {
2856 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2857 scene_out_ptr->connect (state_iter->name);
2865 Session::reconnect_mtc_ports ()
2867 boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
2873 mtc_in_ptr->disconnect_all ();
2875 std::vector<EngineStateController::MidiPortState> midi_port_states;
2876 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2878 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2880 for (; state_iter != midi_port_states.end(); ++state_iter) {
2881 if (state_iter->available && state_iter->mtc_in) {
2882 mtc_in_ptr->connect (state_iter->name);
2886 if (!_midi_ports->mtc_input_port ()->connected () &&
2887 config.get_external_sync () &&
2888 (Config->get_sync_source () == MTC) ) {
2889 config.set_external_sync (false);
2892 if ( ARDOUR::Profile->get_trx () ) {
2893 // Tracks need this signal to update timecode_source_dropdown
2894 MtcOrLtcInputPortChanged (); //emit signal
2899 Session::reconnect_mmc_ports(bool inputs)
2901 if (inputs ) { // get all enabled midi input ports
2903 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
2905 mmc_in_ptr->disconnect_all ();
2906 std::vector<std::string> enabled_midi_inputs;
2907 EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
2909 std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
2911 for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
2912 mmc_in_ptr->connect (*port_iter);
2916 } else { // get all enabled midi output ports
2918 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
2920 mmc_out_ptr->disconnect_all ();
2921 std::vector<std::string> enabled_midi_outputs;
2922 EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
2924 std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
2926 for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
2927 mmc_out_ptr->connect (*port_iter);
2936 Session::ensure_route_presentation_info_gap (PresentationInfo::order_t first_new_order, uint32_t how_many)
2938 if (first_new_order == PresentationInfo::max_order) {
2939 /* adding at end, no worries */
2943 /* create a gap in the presentation info to accomodate @param how_many
2947 get_stripables (sl);
2949 for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
2950 boost::shared_ptr<Stripable> s (*si);
2952 if (s->is_monitor() || s->is_auditioner()) {
2956 if (s->presentation_info().order () >= first_new_order) {
2957 s->set_presentation_order (s->presentation_info().order () + how_many);
2962 /** Caller must not hold process lock
2963 * @param name_template string to use for the start of the name, or "" to use "Audio".
2965 list< boost::shared_ptr<AudioTrack> >
2966 Session::new_audio_track (int input_channels, int output_channels, RouteGroup* route_group,
2967 uint32_t how_many, string name_template, PresentationInfo::order_t order,
2971 uint32_t track_id = 0;
2973 RouteList new_routes;
2974 list<boost::shared_ptr<AudioTrack> > ret;
2976 const string name_pattern = default_track_name_pattern (DataType::AUDIO);
2977 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2981 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
2982 error << "cannot find name for new audio track" << endmsg;
2986 boost::shared_ptr<AudioTrack> track;
2989 track.reset (new AudioTrack (*this, track_name, mode));
2991 if (track->init ()) {
2995 if (Profile->get_mixbus ()) {
2996 track->set_strict_io (true);
2999 if (ARDOUR::Profile->get_trx ()) {
3000 // TRACKS considers it's not a USE CASE, it's
3001 // a piece of behavior of the session model:
3003 // Gain for a newly created route depends on
3004 // the current output_auto_connect mode:
3006 // 0 for Stereo Out mode
3008 if (Config->get_output_auto_connect() & AutoConnectMaster) {
3009 track->gain_control()->set_value (dB_to_coefficient (0), Controllable::NoGroup);
3013 track->use_new_diskstream();
3015 BOOST_MARK_TRACK (track);
3018 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3020 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3021 error << string_compose (
3022 _("cannot configure %1 in/%2 out configuration for new audio track"),
3023 input_channels, output_channels)
3028 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3029 error << string_compose (
3030 _("cannot configure %1 in/%2 out configuration for new audio track"),
3031 input_channels, output_channels)
3038 route_group->add (track);
3041 track->non_realtime_input_change();
3043 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
3045 new_routes.push_back (track);
3046 ret.push_back (track);
3049 catch (failed_constructor &err) {
3050 error << _("Session: could not create new audio track.") << endmsg;
3054 catch (AudioEngine::PortRegistrationFailure& pfe) {
3056 error << pfe.what() << endmsg;
3064 if (!new_routes.empty()) {
3065 StateProtector sp (this);
3066 if (Profile->get_trx()) {
3067 add_routes (new_routes, false, false, false, order);
3069 add_routes (new_routes, true, true, false, order);
3076 /** Caller must not hold process lock.
3077 * @param name_template string to use for the start of the name, or "" to use "Bus".
3080 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template,
3081 PresentationInfo::Flag flags, PresentationInfo::order_t order)
3084 uint32_t bus_id = 0;
3088 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3091 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3092 error << "cannot find name for new audio bus" << endmsg;
3097 boost::shared_ptr<Route> bus (new Route (*this, bus_name, flags, DataType::AUDIO));
3103 if (Profile->get_mixbus ()) {
3104 bus->set_strict_io (true);
3107 BOOST_MARK_ROUTE(bus);
3110 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3112 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3113 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3114 input_channels, output_channels)
3120 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3121 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3122 input_channels, output_channels)
3129 route_group->add (bus);
3132 bus->add_internal_return ();
3133 ret.push_back (bus);
3136 catch (failed_constructor &err) {
3137 error << _("Session: could not create new audio route.") << endmsg;
3141 catch (AudioEngine::PortRegistrationFailure& pfe) {
3142 error << pfe.what() << endmsg;
3152 StateProtector sp (this);
3153 if (Profile->get_trx()) {
3154 add_routes (ret, false, false, false, order);
3156 add_routes (ret, false, true, true, order); // autoconnect // outputs only
3165 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base, PlaylistDisposition pd)
3169 if (!tree.read (template_path.c_str())) {
3173 return new_route_from_template (how_many, *tree.root(), name_base, pd);
3177 Session::new_route_from_template (uint32_t how_many, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3180 uint32_t number = 0;
3181 const uint32_t being_added = how_many;
3182 /* This will prevent the use of any existing XML-provided PBD::ID
3185 Stateful::ForceIDRegeneration force_ids;
3186 IO::disable_connecting ();
3190 /* We're going to modify the node contents a bit so take a
3191 * copy. The node may be re-used when duplicating more than once.
3194 XMLNode node_copy (node);
3199 if (!name_base.empty()) {
3201 /* if we're adding more than one routes, force
3202 * all the names of the new routes to be
3203 * numbered, via the final parameter.
3206 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3207 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3213 string const route_name = node_copy.property(X_("name"))->value ();
3215 /* generate a new name by adding a number to the end of the template name */
3216 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3217 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3218 abort(); /*NOTREACHED*/
3222 /* set this name in the XML description that we are about to use */
3224 bool rename_playlist;
3227 rename_playlist = true;
3232 rename_playlist = false;
3235 Route::set_name_in_state (node_copy, name, rename_playlist);
3237 /* trim bitslots from listen sends so that new ones are used */
3238 XMLNodeList children = node_copy.children ();
3239 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3240 if ((*i)->name() == X_("Processor")) {
3241 /* ForceIDRegeneration does not catch the following */
3242 XMLProperty const * role = (*i)->property (X_("role"));
3243 XMLProperty const * type = (*i)->property (X_("type"));
3244 if (role && role->value() == X_("Aux")) {
3245 /* check if the target bus exists.
3246 * we should not save aux-sends in templates.
3248 XMLProperty const * target = (*i)->property (X_("target"));
3250 (*i)->add_property ("type", "dangling-aux-send");
3253 boost::shared_ptr<Route> r = route_by_id (target->value());
3254 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3255 (*i)->add_property ("type", "dangling-aux-send");
3259 if (role && role->value() == X_("Listen")) {
3260 (*i)->remove_property (X_("bitslot"));
3262 else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3264 Delivery::Role xrole;
3265 uint32_t bitslot = 0;
3266 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3267 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3268 snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
3269 (*i)->remove_property (X_("bitslot"));
3270 (*i)->remove_property (X_("name"));
3271 (*i)->add_property ("bitslot", buf);
3272 (*i)->add_property ("name", name);
3274 else if (type && type->value() == X_("intreturn")) {
3275 (*i)->remove_property (X_("bitslot"));
3276 (*i)->add_property ("ignore-bitslot", "1");
3278 else if (type && type->value() == X_("return")) {
3279 // Return::set_state() generates a new one
3280 (*i)->remove_property (X_("bitslot"));
3282 else if (type && type->value() == X_("port")) {
3283 // PortInsert::set_state() handles the bitslot
3284 (*i)->remove_property (X_("bitslot"));
3285 (*i)->add_property ("ignore-name", "1");
3290 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3293 error << _("Session: cannot create track/bus from template description") << endmsg;
3297 if (boost::dynamic_pointer_cast<Track>(route)) {
3298 /* force input/output change signals so that the new diskstream
3299 picks up the configuration of the route. During session
3300 loading this normally happens in a different way.
3303 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3305 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3306 change.after = route->input()->n_ports();
3307 route->input()->changed (change, this);
3308 change.after = route->output()->n_ports();
3309 route->output()->changed (change, this);
3312 boost::shared_ptr<Track> track;
3314 if ((track = boost::dynamic_pointer_cast<Track> (route))) {
3317 track->use_new_playlist ();
3320 track->use_copy_playlist ();
3327 ret.push_back (route);
3330 catch (failed_constructor &err) {
3331 error << _("Session: could not create new route from template") << endmsg;
3335 catch (AudioEngine::PortRegistrationFailure& pfe) {
3336 error << pfe.what() << endmsg;
3345 StateProtector sp (this);
3346 if (Profile->get_trx()) {
3347 add_routes (ret, false, false, false, PresentationInfo::max_order);
3349 add_routes (ret, true, true, false, PresentationInfo::max_order);
3351 IO::enable_connecting ();
3358 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t order)
3361 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3362 add_routes_inner (new_routes, input_auto_connect, output_auto_connect, order);
3365 error << _("Adding new tracks/busses failed") << endmsg;
3370 update_latency (true);
3371 update_latency (false);
3376 save_state (_current_snapshot_name);
3379 update_route_record_state ();
3381 RouteAdded (new_routes); /* EMIT SIGNAL */
3385 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t order)
3387 ChanCount existing_inputs;
3388 ChanCount existing_outputs;
3392 count_existing_track_channels (existing_inputs, existing_outputs);
3395 RCUWriter<RouteList> writer (routes);
3396 boost::shared_ptr<RouteList> r = writer.get_copy ();
3397 r->insert (r->end(), new_routes.begin(), new_routes.end());
3398 n_routes = r->size();
3400 /* if there is no control out and we're not in the middle of loading,
3401 * resort the graph here. if there is a control out, we will resort
3402 * toward the end of this method. if we are in the middle of loading,
3403 * we will resort when done.
3406 if (!_monitor_out && IO::connecting_legal) {
3407 resort_routes_using (r);
3411 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("ensure order gap starting at %1 for %2\n", order, new_routes.size()));
3412 ensure_route_presentation_info_gap (order, new_routes.size());
3414 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x, ++added) {
3416 boost::weak_ptr<Route> wpr (*x);
3417 boost::shared_ptr<Route> r (*x);
3419 r->solo_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2,wpr));
3420 r->solo_isolate_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3421 r->mute_control()->Changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3423 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3424 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3425 r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
3427 if (r->is_master()) {
3431 if (r->is_monitor()) {
3435 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3437 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3438 track_playlist_changed (boost::weak_ptr<Track> (tr));
3439 tr->rec_enable_control()->Changed.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3441 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3443 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3444 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3448 if (!r->presentation_info().special()) {
3450 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("checking PI state for %1\n", r->name()));
3452 /* presentation info order may already have been set from XML */
3454 if (!r->presentation_info().order_set()) {
3456 if (order == PresentationInfo::max_order) {
3457 /* just add to the end */
3458 r->set_presentation_order (n_routes + added, false);
3459 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
3461 r->set_presentation_order (order + added);
3462 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
3465 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
3469 #if !defined(__APPLE__) && !defined(__FreeBSD__)
3470 /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
3471 * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
3473 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
3475 r->presentation_info().order(),
3476 enum_2_string (r->presentation_info().flags()),
3477 r->presentation_info()));
3481 if (input_auto_connect || output_auto_connect) {
3482 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3483 existing_inputs += r->n_inputs();
3484 existing_outputs += r->n_outputs();
3490 if (_monitor_out && IO::connecting_legal) {
3491 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3493 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3494 if ((*x)->is_monitor()) {
3496 } else if ((*x)->is_master()) {
3499 (*x)->enable_monitor_send ();
3504 reassign_track_numbers ();
3508 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3510 boost::shared_ptr<RouteList> r = routes.reader ();
3511 boost::shared_ptr<Send> s;
3513 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3514 if ((s = (*i)->internal_send_for (dest)) != 0) {
3515 s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3521 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3523 boost::shared_ptr<RouteList> r = routes.reader ();
3524 boost::shared_ptr<Send> s;
3526 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3527 if ((s = (*i)->internal_send_for (dest)) != 0) {
3528 s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3534 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3536 boost::shared_ptr<RouteList> r = routes.reader ();
3537 boost::shared_ptr<Send> s;
3539 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3540 if ((s = (*i)->internal_send_for (dest)) != 0) {
3541 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3546 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3548 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3550 boost::shared_ptr<RouteList> r = routes.reader ();
3551 boost::shared_ptr<RouteList> t (new RouteList);
3553 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3554 /* no MIDI sends because there are no MIDI busses yet */
3555 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3560 add_internal_sends (dest, p, t);
3564 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3566 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3567 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3572 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3574 add_internal_send (dest, sender->before_processor_for_index (index), sender);
3578 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3580 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3584 if (!dest->internal_return()) {
3585 dest->add_internal_return ();
3588 sender->add_aux_send (dest, before);
3594 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3596 { // RCU Writer scope
3597 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3598 RCUWriter<RouteList> writer (routes);
3599 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3602 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3604 if (*iter == _master_out) {
3608 (*iter)->solo_control()->set_value (0.0, Controllable::NoGroup);
3612 /* deleting the master out seems like a dumb
3613 idea, but its more of a UI policy issue
3617 if (*iter == _master_out) {
3618 _master_out = boost::shared_ptr<Route> ();
3621 if (*iter == _monitor_out) {
3622 _monitor_out.reset ();
3625 // We need to disconnect the route's inputs and outputs
3627 (*iter)->input()->disconnect (0);
3628 (*iter)->output()->disconnect (0);
3630 /* if the route had internal sends sending to it, remove them */
3631 if ((*iter)->internal_return()) {
3633 boost::shared_ptr<RouteList> r = routes.reader ();
3634 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3635 boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3637 (*i)->remove_processor (s);
3642 /* if the monitoring section had a pointer to this route, remove it */
3643 if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3644 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3645 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3646 (*iter)->remove_aux_or_listen (_monitor_out);
3649 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3650 if (mt && mt->step_editing()) {
3651 if (_step_editors > 0) {
3657 /* writer goes out of scope, forces route list update */
3659 } // end of RCU Writer scope
3661 update_route_solo_state ();
3662 update_latency_compensation ();
3665 /* Re-sort routes to remove the graph's current references to the one that is
3666 * going away, then flush old references out of the graph.
3667 * Wave Tracks: reconnect routes
3670 #ifdef USE_TRACKS_CODE_FEATURES
3671 reconnect_existing_routes(true, false);
3673 routes.flush (); // maybe unsafe, see below.
3677 if (_process_graph && !(_state_of_the_state & Deletion)) {
3678 _process_graph->clear_other_chain ();
3681 /* get rid of it from the dead wood collection in the route list manager */
3682 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3686 /* try to cause everyone to drop their references
3687 * and unregister ports from the backend
3690 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3691 (*iter)->drop_references ();
3694 if (_state_of_the_state & Deletion) {
3698 PresentationInfo::Change(); /* EMIT SIGNAL */
3700 /* save the new state of the world */
3702 if (save_state (_current_snapshot_name)) {
3703 save_history (_current_snapshot_name);
3706 update_route_record_state ();
3710 Session::remove_route (boost::shared_ptr<Route> route)
3712 boost::shared_ptr<RouteList> rl (new RouteList);
3713 rl->push_back (route);
3718 Session::route_mute_changed ()
3724 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3726 boost::shared_ptr<Route> route (wpr.lock());
3732 assert (Config->get_solo_control_is_listen_control());
3734 if (route->solo_control()->soloed_by_self_or_masters()) {
3736 if (Config->get_exclusive_solo()) {
3738 RouteGroup* rg = route->route_group ();
3739 const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3741 boost::shared_ptr<RouteList> r = routes.reader ();
3743 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3744 if ((*i) == route) {
3745 /* already changed */
3749 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3750 /* route does not get solo propagated to it */
3754 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3755 /* this route is a part of the same solo group as the route
3756 * that was changed. Changing that route did change or will
3757 * change all group members appropriately, so we can ignore it
3762 (*i)->solo_control()->set_value (0.0, Controllable::NoGroup);
3768 } else if (_listen_cnt > 0) {
3773 update_route_solo_state ();
3777 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3779 boost::shared_ptr<Route> route (wpr.lock());
3785 bool send_changed = false;
3787 if (route->solo_isolate_control()->solo_isolated()) {
3788 if (_solo_isolated_cnt == 0) {
3789 send_changed = true;
3791 _solo_isolated_cnt++;
3792 } else if (_solo_isolated_cnt > 0) {
3793 _solo_isolated_cnt--;
3794 if (_solo_isolated_cnt == 0) {
3795 send_changed = true;
3800 IsolatedChanged (); /* EMIT SIGNAL */
3805 Session::route_solo_changed (bool self_solo_changed, Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3807 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_changed));
3809 boost::shared_ptr<Route> route (wpr.lock());
3815 if (Config->get_solo_control_is_listen_control()) {
3816 route_listen_changed (group_override, wpr);
3820 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()));
3822 if (route->solo_control()->transitioned_into_solo() == 0) {
3823 /* route solo changed by upstream/downstream; not interesting
3826 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()));
3830 if (route->solo_control()->transitioned_into_solo() == 0) {
3831 /* reason for being soloed changed (e.g. master went away, we
3832 * took over the master state), but actual status did
3833 * not. nothing to do.
3835 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: solo change was change in reason, not status\n", route->name()));
3838 boost::shared_ptr<RouteList> r = routes.reader ();
3839 int32_t delta = route->solo_control()->transitioned_into_solo ();
3841 /* the route may be a member of a group that has shared-solo
3842 * semantics. If so, then all members of that group should follow the
3843 * solo of the changed route. But ... this is optional, controlled by a
3844 * Controllable::GroupControlDisposition.
3846 * The first argument to the signal that this method is connected to is the
3847 * GroupControlDisposition value that was used to change solo.
3849 * If the solo change was done with group semantics (either InverseGroup
3850 * (force the entire group to change even if the group shared solo is
3851 * disabled) or UseGroup (use the group, which may or may not have the
3852 * shared solo property enabled)) then as we propagate the change to
3853 * the entire session we should IGNORE THE GROUP that the changed route
3857 RouteGroup* rg = route->route_group ();
3858 const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3860 if (delta == 1 && Config->get_exclusive_solo()) {
3862 /* new solo: disable all other solos, but not the group if its solo-enabled */
3864 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3866 if ((*i) == route) {
3867 /* already changed */
3871 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3872 /* route does not get solo propagated to it */
3876 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3877 /* this route is a part of the same solo group as the route
3878 * that was changed. Changing that route did change or will
3879 * change all group members appropriately, so we can ignore it
3885 (*i)->solo_control()->set_value (0.0, group_override);
3889 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3891 RouteList uninvolved;
3893 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3895 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3896 bool via_sends_only;
3897 bool in_signal_flow;
3899 if ((*i) == route) {
3900 /* already changed */
3904 if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
3905 /* route does not get solo propagated to it */
3909 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3910 /* this route is a part of the same solo group as the route
3911 * that was changed. Changing that route did change or will
3912 * change all group members appropriately, so we can ignore it
3918 in_signal_flow = false;
3920 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3922 if ((*i)->feeds (route, &via_sends_only)) {
3923 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3924 if (!via_sends_only) {
3925 if (!route->soloed_by_others_upstream()) {
3926 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3928 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
3931 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3933 in_signal_flow = true;
3935 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3938 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3940 if (route->feeds (*i, &via_sends_only)) {
3941 /* propagate solo upstream only if routing other than
3942 sends is involved, but do consider the other route
3943 (*i) to be part of the signal flow even if only
3946 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3950 route->soloed_by_others_downstream(),
3951 route->soloed_by_others_upstream()));
3952 if (!via_sends_only) {
3953 //NB. Triggers Invert Push, which handles soloed by downstream
3954 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3955 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3957 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3959 in_signal_flow = true;
3961 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3964 if (!in_signal_flow) {
3965 uninvolved.push_back (*i);
3969 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3971 update_route_solo_state (r);
3973 /* now notify that the mute state of the routes not involved in the signal
3974 pathway of the just-solo-changed route may have altered.
3977 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3978 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3979 (*i)->act_on_mute ();
3980 (*i)->mute_control()->Changed (false, Controllable::NoGroup);
3983 SoloChanged (); /* EMIT SIGNAL */
3988 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3990 /* now figure out if anything that matters is soloed (or is "listening")*/
3992 bool something_soloed = false;
3993 bool something_listening = false;
3994 uint32_t listeners = 0;
3995 uint32_t isolated = 0;
3998 r = routes.reader();
4001 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4002 if ((*i)->can_solo()) {
4003 if (Config->get_solo_control_is_listen_control()) {
4004 if ((*i)->self_soloed() || (*i)->solo_control()->get_masters_value()) {
4006 something_listening = true;
4009 (*i)->set_listen (false);
4010 if ((*i)->can_solo() && ((*i)->self_soloed() || (*i)->solo_control()->get_masters_value())) {
4011 something_soloed = true;
4016 if ((*i)->solo_isolate_control()->solo_isolated()) {
4021 if (something_soloed != _non_soloed_outs_muted) {
4022 _non_soloed_outs_muted = something_soloed;
4023 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
4026 if (something_listening != _listening) {
4027 _listening = something_listening;
4028 SoloActive (_listening);
4031 _listen_cnt = listeners;
4033 if (isolated != _solo_isolated_cnt) {
4034 _solo_isolated_cnt = isolated;
4035 IsolatedChanged (); /* EMIT SIGNAL */
4038 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
4039 something_soloed, listeners, isolated));
4043 Session::get_stripables (StripableList& sl) const
4045 boost::shared_ptr<RouteList> r = routes.reader ();
4046 sl.insert (sl.end(), r->begin(), r->end());
4048 VCAList v = _vca_manager->vcas ();
4049 sl.insert (sl.end(), v.begin(), v.end());
4052 boost::shared_ptr<RouteList>
4053 Session::get_routes_with_internal_returns() const
4055 boost::shared_ptr<RouteList> r = routes.reader ();
4056 boost::shared_ptr<RouteList> rl (new RouteList);
4058 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4059 if ((*i)->internal_return ()) {
4067 Session::io_name_is_legal (const std::string& name) const
4069 boost::shared_ptr<RouteList> r = routes.reader ();
4071 for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
4072 if (name == *reserved) {
4073 if (!route_by_name (*reserved)) {
4074 /* first instance of a reserved name is allowed */
4077 /* all other instances of a reserved name are not allowed */
4082 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4083 if ((*i)->name() == name) {
4087 if ((*i)->has_io_processor_named (name)) {
4096 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4099 vector<string> connections;
4101 /* if we are passed only a single route and we're not told to turn
4102 * others off, then just do the simple thing.
4105 if (flip_others == false && rl->size() == 1) {
4106 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4108 mt->set_input_active (onoff);
4113 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4115 PortSet& ps ((*rt)->input()->ports());
4117 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4118 p->get_connections (connections);
4121 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4122 routes_using_input_from (*s, rl2);
4125 /* scan all relevant routes to see if others are on or off */
4127 bool others_are_already_on = false;
4129 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4131 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4137 if ((*r) != (*rt)) {
4138 if (mt->input_active()) {
4139 others_are_already_on = true;
4142 /* this one needs changing */
4143 mt->set_input_active (onoff);
4149 /* globally reverse other routes */
4151 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4152 if ((*r) != (*rt)) {
4153 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4155 mt->set_input_active (!others_are_already_on);
4164 Session::routes_using_input_from (const string& str, RouteList& rl)
4166 boost::shared_ptr<RouteList> r = routes.reader();
4168 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4169 if ((*i)->input()->connected_to (str)) {
4175 boost::shared_ptr<Route>
4176 Session::route_by_name (string name) const
4178 boost::shared_ptr<RouteList> r = routes.reader ();
4180 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4181 if ((*i)->name() == name) {
4186 return boost::shared_ptr<Route> ((Route*) 0);
4189 boost::shared_ptr<Route>
4190 Session::route_by_id (PBD::ID id) const
4192 boost::shared_ptr<RouteList> r = routes.reader ();
4194 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4195 if ((*i)->id() == id) {
4200 return boost::shared_ptr<Route> ((Route*) 0);
4203 boost::shared_ptr<Processor>
4204 Session::processor_by_id (PBD::ID id) const
4206 boost::shared_ptr<RouteList> r = routes.reader ();
4208 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4209 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4215 return boost::shared_ptr<Processor> ();
4218 boost::shared_ptr<Track>
4219 Session::track_by_diskstream_id (PBD::ID id) const
4221 boost::shared_ptr<RouteList> r = routes.reader ();
4223 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4224 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4225 if (t && t->using_diskstream_id (id)) {
4230 return boost::shared_ptr<Track> ();
4233 boost::shared_ptr<Route>
4234 Session::get_remote_nth_route (PresentationInfo::order_t n) const
4236 return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
4239 boost::shared_ptr<Stripable>
4240 Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
4243 PresentationInfo::order_t match_cnt = 0;
4245 get_stripables (sl);
4246 sl.sort (Stripable::PresentationOrderSorter());
4248 for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
4249 if ((*s)->presentation_info().flag_match (flags)) {
4250 if (match_cnt++ == n) {
4256 /* there is no nth stripable that matches the given flags */
4257 return boost::shared_ptr<Stripable>();
4260 boost::shared_ptr<Route>
4261 Session::route_by_selected_count (uint32_t id) const
4263 boost::shared_ptr<RouteList> r = routes.reader ();
4265 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4266 /* NOT IMPLEMENTED */
4269 return boost::shared_ptr<Route> ((Route*) 0);
4272 struct PresentationOrderSorter {
4273 bool operator() (boost::shared_ptr<Stripable> a, boost::shared_ptr<Stripable> b) {
4274 if (a->presentation_info().special() && !b->presentation_info().special()) {
4275 /* a is not ordered, b is; b comes before a */
4277 } else if (!b->presentation_info().order_set() && a->presentation_info().order_set()) {
4278 /* b is not ordered, a is; a comes before b */
4281 return a->presentation_info().order() < b->presentation_info().order();
4287 Session::reassign_track_numbers ()
4291 RouteList r (*(routes.reader ()));
4292 PresentationOrderSorter sorter;
4295 StateProtector sp (this);
4297 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4298 if (boost::dynamic_pointer_cast<Track> (*i)) {
4299 (*i)->set_track_number(++tn);
4301 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4302 (*i)->set_track_number(--bn);
4305 const uint32_t decimals = ceilf (log10f (tn + 1));
4306 const bool decimals_changed = _track_number_decimals != decimals;
4307 _track_number_decimals = decimals;
4309 if (decimals_changed && config.get_track_name_number ()) {
4310 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4311 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4313 t->resync_track_name();
4316 // trigger GUI re-layout
4317 config.ParameterChanged("track-name-number");
4321 if (DEBUG_ENABLED(DEBUG::OrderKeys)) {
4322 boost::shared_ptr<RouteList> rl = routes.reader ();
4323 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4324 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 numbered %2\n", (*i)->name(), (*i)->track_number()));
4332 Session::playlist_region_added (boost::weak_ptr<Region> w)
4334 boost::shared_ptr<Region> r = w.lock ();
4339 /* These are the operations that are currently in progress... */
4340 list<GQuark> curr = _current_trans_quarks;
4343 /* ...and these are the operations during which we want to update
4344 the session range location markers.
4347 ops.push_back (Operations::capture);
4348 ops.push_back (Operations::paste);
4349 ops.push_back (Operations::duplicate_region);
4350 ops.push_back (Operations::insert_file);
4351 ops.push_back (Operations::insert_region);
4352 ops.push_back (Operations::drag_region_brush);
4353 ops.push_back (Operations::region_drag);
4354 ops.push_back (Operations::selection_grab);
4355 ops.push_back (Operations::region_fill);
4356 ops.push_back (Operations::fill_selection);
4357 ops.push_back (Operations::create_region);
4358 ops.push_back (Operations::region_copy);
4359 ops.push_back (Operations::fixed_time_region_copy);
4362 /* See if any of the current operations match the ones that we want */
4364 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4366 /* If so, update the session range markers */
4368 maybe_update_session_range (r->position (), r->last_frame ());
4372 /** Update the session range markers if a is before the current start or
4373 * b is after the current end.
4376 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4378 if (_state_of_the_state & Loading) {
4382 framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4384 if (_session_range_location == 0) {
4386 set_session_range_location (a, b + session_end_marker_shift_samples);
4390 if (a < _session_range_location->start()) {
4391 _session_range_location->set_start (a);
4394 if (_session_range_end_is_free && (b > _session_range_location->end())) {
4395 _session_range_location->set_end (b);
4401 Session::set_end_is_free (bool yn)
4403 _session_range_end_is_free = yn;
4407 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4409 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4410 maybe_update_session_range (i->to, i->to + i->length);
4415 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4417 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4418 maybe_update_session_range (i->from, i->to);
4422 /* Region management */
4424 boost::shared_ptr<Region>
4425 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4427 const RegionFactory::RegionMap& regions (RegionFactory::regions());
4428 RegionFactory::RegionMap::const_iterator i;
4429 boost::shared_ptr<Region> region;
4431 Glib::Threads::Mutex::Lock lm (region_lock);
4433 for (i = regions.begin(); i != regions.end(); ++i) {
4437 if (region->whole_file()) {
4439 if (child->source_equivalent (region)) {
4445 return boost::shared_ptr<Region> ();
4449 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4451 set<boost::shared_ptr<Region> > relevant_regions;
4453 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4454 RegionFactory::get_regions_using_source (*s, relevant_regions);
4457 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4458 set<boost::shared_ptr<Region> >::iterator tmp;
4463 playlists->destroy_region (*r);
4464 RegionFactory::map_remove (*r);
4466 (*r)->drop_sources ();
4467 (*r)->drop_references ();
4469 relevant_regions.erase (r);
4474 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4477 Glib::Threads::Mutex::Lock ls (source_lock);
4478 /* remove from the main source list */
4479 sources.erase ((*s)->id());
4482 (*s)->mark_for_remove ();
4483 (*s)->drop_references ();
4492 Session::remove_last_capture ()
4494 list<boost::shared_ptr<Source> > srcs;
4496 boost::shared_ptr<RouteList> rl = routes.reader ();
4497 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4498 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4503 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4506 srcs.insert (srcs.end(), l.begin(), l.end());
4511 destroy_sources (srcs);
4513 save_state (_current_snapshot_name);
4518 /* Source Management */
4521 Session::add_source (boost::shared_ptr<Source> source)
4523 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4524 pair<SourceMap::iterator,bool> result;
4526 entry.first = source->id();
4527 entry.second = source;
4530 Glib::Threads::Mutex::Lock lm (source_lock);
4531 result = sources.insert (entry);
4534 if (result.second) {
4536 /* yay, new source */
4538 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4541 if (!fs->within_session()) {
4542 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4548 boost::shared_ptr<AudioFileSource> afs;
4550 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4551 if (Config->get_auto_analyse_audio()) {
4552 Analyser::queue_source_for_analysis (source, false);
4556 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4561 Session::remove_source (boost::weak_ptr<Source> src)
4563 if (_state_of_the_state & Deletion) {
4567 SourceMap::iterator i;
4568 boost::shared_ptr<Source> source = src.lock();
4575 Glib::Threads::Mutex::Lock lm (source_lock);
4577 if ((i = sources.find (source->id())) != sources.end()) {
4582 if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4584 /* save state so we don't end up with a session file
4585 referring to non-existent sources.
4588 save_state (_current_snapshot_name);
4592 boost::shared_ptr<Source>
4593 Session::source_by_id (const PBD::ID& id)
4595 Glib::Threads::Mutex::Lock lm (source_lock);
4596 SourceMap::iterator i;
4597 boost::shared_ptr<Source> source;
4599 if ((i = sources.find (id)) != sources.end()) {
4606 boost::shared_ptr<AudioFileSource>
4607 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4609 /* Restricted to audio files because only audio sources have channel
4613 Glib::Threads::Mutex::Lock lm (source_lock);
4615 for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4616 boost::shared_ptr<AudioFileSource> afs
4617 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4619 if (afs && afs->path() == path && chn == afs->channel()) {
4624 return boost::shared_ptr<AudioFileSource>();
4627 boost::shared_ptr<MidiSource>
4628 Session::midi_source_by_path (const std::string& path) const
4630 /* Restricted to MIDI files because audio sources require a channel
4631 for unique identification, in addition to a path.
4634 Glib::Threads::Mutex::Lock lm (source_lock);
4636 for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4637 boost::shared_ptr<MidiSource> ms
4638 = boost::dynamic_pointer_cast<MidiSource>(s->second);
4639 boost::shared_ptr<FileSource> fs
4640 = boost::dynamic_pointer_cast<FileSource>(s->second);
4642 if (ms && fs && fs->path() == path) {
4647 return boost::shared_ptr<MidiSource>();
4651 Session::count_sources_by_origin (const string& path)
4654 Glib::Threads::Mutex::Lock lm (source_lock);
4656 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4657 boost::shared_ptr<FileSource> fs
4658 = boost::dynamic_pointer_cast<FileSource>(i->second);
4660 if (fs && fs->origin() == path) {
4669 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4671 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4672 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4674 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4679 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4681 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4683 if (Glib::path_is_absolute (filepath)) {
4685 /* rip the session dir from the audiofile source */
4687 string session_path;
4688 bool in_another_session = true;
4690 if (filepath.find (interchange_dir_string) != string::npos) {
4692 session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4693 session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4694 session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4695 session_path = Glib::path_get_dirname (session_path); /* now has session path */
4697 /* see if it is within our session */
4699 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4700 if (i->path == session_path) {
4701 in_another_session = false;
4706 in_another_session = false;
4710 if (in_another_session) {
4711 SessionDirectory sd (session_path);
4712 return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4716 /* 1) if file belongs to this session
4717 * it may be a relative path (interchange/...)
4718 * or just basename (session_state, remove source)
4719 * -> just use the basename
4721 std::string filename = Glib::path_get_basename (filepath);
4724 /* 2) if the file is outside our session dir:
4725 * (imported but not copied) add the path for check-summming */
4727 path = Glib::path_get_dirname (filepath);
4730 return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4734 Session::new_audio_source_path_for_embedded (const std::string& path)
4738 * we know that the filename is already unique because it exists
4739 * out in the filesystem.
4741 * However, when we bring it into the session, we could get a
4744 * Eg. two embedded files:
4749 * When merged into session, these collide.
4751 * There will not be a conflict with in-memory sources
4752 * because when the source was created we already picked
4753 * a unique name for it.
4755 * This collision is not likely to be common, but we have to guard
4756 * against it. So, if there is a collision, take the md5 hash of the
4757 * the path, and use that as the filename instead.
4760 SessionDirectory sdir (get_best_session_directory_for_new_audio());
4761 string base = Glib::path_get_basename (path);
4762 string newpath = Glib::build_filename (sdir.sound_path(), base);
4764 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4768 md5.digestString (path.c_str());
4769 md5.writeToString ();
4770 base = md5.digestChars;
4772 string ext = get_suffix (path);
4779 newpath = Glib::build_filename (sdir.sound_path(), base);
4781 /* if this collides, we're screwed */
4783 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4784 error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4793 /** Return true if there are no audio file sources that use @param name as
4794 * the filename component of their path.
4796 * Return false otherwise.
4798 * This method MUST ONLY be used to check in-session, mono files since it
4799 * hard-codes the channel of the audio file source we are looking for as zero.
4801 * If/when Ardour supports native files in non-mono formats, the logic here
4802 * will need to be revisited.
4805 Session::audio_source_name_is_unique (const string& name)
4807 std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4808 vector<space_and_path>::iterator i;
4809 uint32_t existing = 0;
4811 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4813 /* note that we search *without* the extension so that
4814 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4815 in the event that this new name is required for
4816 a file format change.
4819 const string spath = *i;
4821 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4826 /* it is possible that we have the path already
4827 * assigned to a source that has not yet been written
4828 * (ie. the write source for a diskstream). we have to
4829 * check this in order to make sure that our candidate
4830 * path isn't used again, because that can lead to
4831 * two Sources point to the same file with different
4832 * notions of their removability.
4836 string possible_path = Glib::build_filename (spath, name);
4838 if (audio_source_by_path_and_channel (possible_path, 0)) {
4844 return (existing == 0);
4848 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)
4851 const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4853 if (Profile->get_trx() && destructive) {
4855 sstr << setfill ('0') << setw (4) << cnt;
4856 sstr << legalized_base;
4858 sstr << legalized_base;
4860 if (take_required || related_exists) {
4872 } else if (nchan > 2) {
4877 /* XXX what? more than 26 channels! */
4888 /** Return a unique name based on \a base for a new internal audio source */
4890 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4893 string possible_name;
4894 const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4896 bool some_related_source_name_exists = false;
4898 legalized = legalize_for_path (base);
4900 // Find a "version" of the base name that doesn't exist in any of the possible directories.
4902 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4904 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4906 if (audio_source_name_is_unique (possible_name)) {
4910 some_related_source_name_exists = true;
4913 error << string_compose(
4914 _("There are already %1 recordings for %2, which I consider too many."),
4915 limit, base) << endmsg;
4917 throw failed_constructor();
4921 /* We've established that the new name does not exist in any session
4922 * directory, so now find out which one we should use for this new
4926 SessionDirectory sdir (get_best_session_directory_for_new_audio());
4928 std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4933 /** Return a unique name based on `base` for a new internal MIDI source */
4935 Session::new_midi_source_path (const string& base)
4938 char buf[PATH_MAX+1];
4939 const uint32_t limit = 10000;
4941 string possible_path;
4942 string possible_name;
4945 legalized = legalize_for_path (base);
4947 // Find a "version" of the file name that doesn't exist in any of the possible directories.
4948 std::vector<string> sdirs = source_search_path(DataType::MIDI);
4950 /* - the main session folder is the first in the vector.
4951 * - after checking all locations for file-name uniqueness,
4952 * we keep the one from the last iteration as new file name
4953 * - midi files are small and should just be kept in the main session-folder
4955 * -> reverse the array, check main session folder last and use that as location
4958 std::reverse(sdirs.begin(), sdirs.end());
4960 for (cnt = 1; cnt <= limit; ++cnt) {
4962 vector<space_and_path>::iterator i;
4963 uint32_t existing = 0;
4965 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4967 snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4968 possible_name = buf;
4970 possible_path = Glib::build_filename (*i, possible_name);
4972 if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4976 if (midi_source_by_path (possible_path)) {
4981 if (existing == 0) {
4986 error << string_compose(
4987 _("There are already %1 recordings for %2, which I consider too many."),
4988 limit, base) << endmsg;
4994 /* No need to "find best location" for software/app-based RAID, because
4995 MIDI is so small that we always put it in the same place.
4998 return possible_path;
5002 /** Create a new within-session audio source */
5003 boost::shared_ptr<AudioFileSource>
5004 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
5006 const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
5008 if (!path.empty()) {
5009 return boost::dynamic_pointer_cast<AudioFileSource> (
5010 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
5012 throw failed_constructor ();
5016 /** Create a new within-session MIDI source */
5017 boost::shared_ptr<MidiSource>
5018 Session::create_midi_source_for_session (string const & basic_name)
5020 const string path = new_midi_source_path (basic_name);
5022 if (!path.empty()) {
5023 return boost::dynamic_pointer_cast<SMFSource> (
5024 SourceFactory::createWritable (
5025 DataType::MIDI, *this, path, false, frame_rate()));
5027 throw failed_constructor ();
5031 /** Create a new within-session MIDI source */
5032 boost::shared_ptr<MidiSource>
5033 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
5035 /* the caller passes in the track the source will be used in,
5036 so that we can keep the numbering sane.
5038 Rationale: a track with the name "Foo" that has had N
5039 captures carried out so far will ALREADY have a write source
5040 named "Foo-N+1.mid" waiting to be used for the next capture.
5042 If we call new_midi_source_name() we will get "Foo-N+2". But
5043 there is no region corresponding to "Foo-N+1", so when
5044 "Foo-N+2" appears in the track, the gap presents the user
5045 with odd behaviour - why did it skip past Foo-N+1?
5047 We could explain this to the user in some odd way, but
5048 instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
5051 If that attempted rename fails, we get "Foo-N+2.mid" anyway.
5054 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
5056 std::string name = track->steal_write_source_name ();
5059 return boost::shared_ptr<MidiSource>();
5062 /* MIDI files are small, just put them in the first location of the
5063 session source search path.
5066 const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
5068 return boost::dynamic_pointer_cast<SMFSource> (
5069 SourceFactory::createWritable (
5070 DataType::MIDI, *this, path, false, frame_rate()));
5075 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
5077 if (playlist->hidden()) {
5081 playlists->add (playlist);
5084 playlist->release();
5091 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
5093 if (_state_of_the_state & Deletion) {
5097 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
5103 playlists->remove (playlist);
5109 Session::set_audition (boost::shared_ptr<Region> r)
5111 pending_audition_region = r;
5112 add_post_transport_work (PostTransportAudition);
5113 _butler->schedule_transport_work ();
5117 Session::audition_playlist ()
5119 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5120 ev->region.reset ();
5126 Session::register_lua_function (
5127 const std::string& name,
5128 const std::string& script,
5129 const LuaScriptParamList& args
5132 Glib::Threads::Mutex::Lock lm (lua_lock);
5134 lua_State* L = lua.getState();
5136 const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5137 luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5138 for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5139 if ((*i)->optional && !(*i)->is_set) { continue; }
5140 tbl_arg[(*i)->name] = (*i)->value;
5142 (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5147 Session::unregister_lua_function (const std::string& name)
5149 Glib::Threads::Mutex::Lock lm (lua_lock);
5150 (*_lua_del)(name); // throws luabridge::LuaException
5151 lua.collect_garbage ();
5155 std::vector<std::string>
5156 Session::registered_lua_functions ()
5158 Glib::Threads::Mutex::Lock lm (lua_lock);
5159 std::vector<std::string> rv;
5162 luabridge::LuaRef list ((*_lua_list)());
5163 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5164 if (!i.key ().isString ()) { assert(0); continue; }
5165 rv.push_back (i.key ().cast<std::string> ());
5167 } catch (luabridge::LuaException const& e) { }
5172 static void _lua_print (std::string s) {
5173 std::cout << "SessionLua: " << s << "\n";
5178 Session::try_run_lua (pframes_t nframes)
5180 if (_n_lua_scripts == 0) return;
5181 Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5183 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5184 lua.collect_garbage_step ();
5189 Session::setup_lua ()
5192 lua.Print.connect (&_lua_print);
5196 "function ArdourSession ()"
5197 " local self = { scripts = {}, instances = {} }"
5199 " local remove = function (n)"
5200 " self.scripts[n] = nil"
5201 " self.instances[n] = nil"
5202 " Session:scripts_changed()" // call back
5205 " local addinternal = function (n, f, a)"
5206 " assert(type(n) == 'string', 'function-name must be string')"
5207 " assert(type(f) == 'function', 'Given script is a not a function')"
5208 " assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5209 " assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5210 " self.scripts[n] = { ['f'] = f, ['a'] = a }"
5211 " local env = _ENV; env.f = nil env.io = nil env.os = nil env.loadfile = nil env.require = nil env.dofile = nil env.package = nil env.debug = nil"
5212 " 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, Session = Session, PBD = PBD, Timecode = Timecode, Evoral = Evoral, C = C, ARDOUR = ARDOUR }"
5213 " self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5214 " Session:scripts_changed()" // call back
5217 " local add = function (n, b, a)"
5218 " assert(type(b) == 'string', 'ByteCode must be string')"
5219 " load (b)()" // assigns f
5220 " assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5221 " addinternal (n, load(f), a)"
5224 " local run = function (...)"
5225 " for n, s in pairs (self.instances) do"
5226 " local status, err = pcall (s, ...)"
5227 " if not status then"
5228 " print ('fn \"'.. n .. '\": ', err)"
5235 " local cleanup = function ()"
5236 " self.scripts = nil"
5237 " self.instances = nil"
5240 " local list = function ()"
5242 " for n, _ in pairs (self.scripts) do"
5248 " local function basic_serialize (o)"
5249 " if type(o) == \"number\" then"
5250 " return tostring(o)"
5252 " return string.format(\"%q\", o)"
5256 " local function serialize (name, value)"
5257 " local rv = name .. ' = '"
5259 " if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5260 " return rv .. basic_serialize(value) .. ' '"
5261 " elseif type(value) == \"table\" then"
5263 " for k,v in pairs(value) do"
5264 " local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5265 " rv = rv .. serialize(fieldname, v) .. ' '"
5266 " collectgarbage()" // string concatenation allocates a new string :(
5269 " elseif type(value) == \"function\" then"
5270 " return rv .. string.format(\"%q\", string.dump(value, true))"
5272 " error('cannot save a ' .. type(value))"
5277 " local save = function ()"
5278 " return (serialize('scripts', self.scripts))"
5281 " local restore = function (state)"
5282 " self.scripts = {}"
5284 " for n, s in pairs (scripts) do"
5285 " addinternal (n, load(s['f']), s['a'])"
5289 " return { run = run, add = add, remove = remove,"
5290 " list = list, restore = restore, save = save, cleanup = cleanup}"
5293 " sess = ArdourSession ()"
5294 " ArdourSession = nil"
5296 "function ardour () end"
5299 lua_State* L = lua.getState();
5302 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5303 lua.do_command ("sess = nil"); // hide it.
5304 lua.do_command ("collectgarbage()");
5306 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5307 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5308 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5309 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5310 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5311 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5312 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5313 } catch (luabridge::LuaException const& e) {
5314 fatal << string_compose (_("programming error: %1"),
5315 X_("Failed to setup Lua interpreter"))
5317 abort(); /*NOTREACHED*/
5320 LuaBindings::stddef (L);
5321 LuaBindings::common (L);
5322 LuaBindings::dsp (L);
5323 luabridge::push <Session *> (L, this);
5324 lua_setglobal (L, "Session");
5328 Session::scripts_changed ()
5330 assert (!lua_lock.trylock()); // must hold lua_lock
5333 luabridge::LuaRef list ((*_lua_list)());
5335 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5336 if (!i.key ().isString ()) { assert(0); continue; }
5339 _n_lua_scripts = cnt;
5340 } catch (luabridge::LuaException const& e) {
5341 fatal << string_compose (_("programming error: %1"),
5342 X_("Indexing Lua Session Scripts failed."))
5344 abort(); /*NOTREACHED*/
5349 Session::non_realtime_set_audition ()
5351 assert (pending_audition_region);
5352 auditioner->audition_region (pending_audition_region);
5353 pending_audition_region.reset ();
5354 AuditionActive (true); /* EMIT SIGNAL */
5358 Session::audition_region (boost::shared_ptr<Region> r)
5360 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5366 Session::cancel_audition ()
5371 if (auditioner->auditioning()) {
5372 auditioner->cancel_audition ();
5373 AuditionActive (false); /* EMIT SIGNAL */
5378 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
5380 if (a->is_monitor()) {
5383 if (b->is_monitor()) {
5386 return a->presentation_info().order() < b->presentation_info().order();
5390 Session::is_auditioning () const
5392 /* can be called before we have an auditioner object */
5394 return auditioner->auditioning();
5401 Session::graph_reordered ()
5403 /* don't do this stuff if we are setting up connections
5404 from a set_state() call or creating new tracks. Ditto for deletion.
5407 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5411 /* every track/bus asked for this to be handled but it was deferred because
5412 we were connecting. do it now.
5415 request_input_change_handling ();
5419 /* force all diskstreams to update their capture offset values to
5420 reflect any changes in latencies within the graph.
5423 boost::shared_ptr<RouteList> rl = routes.reader ();
5424 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5425 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5427 tr->set_capture_offset ();
5432 /** @return Number of frames that there is disk space available to write,
5435 boost::optional<framecnt_t>
5436 Session::available_capture_duration ()
5438 Glib::Threads::Mutex::Lock lm (space_lock);
5440 if (_total_free_4k_blocks_uncertain) {
5441 return boost::optional<framecnt_t> ();
5444 float sample_bytes_on_disk = 4.0; // keep gcc happy
5446 switch (config.get_native_file_data_format()) {
5448 sample_bytes_on_disk = 4.0;
5452 sample_bytes_on_disk = 3.0;
5456 sample_bytes_on_disk = 2.0;
5460 /* impossible, but keep some gcc versions happy */
5461 fatal << string_compose (_("programming error: %1"),
5462 X_("illegal native file data format"))
5464 abort(); /*NOTREACHED*/
5467 double scale = 4096.0 / sample_bytes_on_disk;
5469 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5470 return max_framecnt;
5473 return (framecnt_t) floor (_total_free_4k_blocks * scale);
5477 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5480 RCUWriter<BundleList> writer (_bundles);
5481 boost::shared_ptr<BundleList> b = writer.get_copy ();
5482 b->push_back (bundle);
5486 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5493 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5495 bool removed = false;
5498 RCUWriter<BundleList> writer (_bundles);
5499 boost::shared_ptr<BundleList> b = writer.get_copy ();
5500 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5502 if (i != b->end()) {
5509 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5515 boost::shared_ptr<Bundle>
5516 Session::bundle_by_name (string name) const
5518 boost::shared_ptr<BundleList> b = _bundles.reader ();
5520 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5521 if ((*i)->name() == name) {
5526 return boost::shared_ptr<Bundle> ();
5530 Session::tempo_map_changed (const PropertyChange&)
5534 playlists->update_after_tempo_map_change ();
5536 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5542 Session::gui_tempo_map_changed ()
5546 playlists->update_after_tempo_map_change ();
5548 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5552 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5554 for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5555 (*i)->recompute_frames_from_bbt ();
5559 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5560 * the given count with the current block size.
5563 Session::ensure_buffers (ChanCount howmany)
5565 BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5569 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5571 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5572 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5577 Session::next_insert_id ()
5579 /* this doesn't really loop forever. just think about it */
5582 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5583 if (!insert_bitset[n]) {
5584 insert_bitset[n] = true;
5590 /* none available, so resize and try again */
5592 insert_bitset.resize (insert_bitset.size() + 16, false);
5597 Session::next_send_id ()
5599 /* this doesn't really loop forever. just think about it */
5602 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5603 if (!send_bitset[n]) {
5604 send_bitset[n] = true;
5610 /* none available, so resize and try again */
5612 send_bitset.resize (send_bitset.size() + 16, false);
5617 Session::next_aux_send_id ()
5619 /* this doesn't really loop forever. just think about it */
5622 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5623 if (!aux_send_bitset[n]) {
5624 aux_send_bitset[n] = true;
5630 /* none available, so resize and try again */
5632 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5637 Session::next_return_id ()
5639 /* this doesn't really loop forever. just think about it */
5642 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5643 if (!return_bitset[n]) {
5644 return_bitset[n] = true;
5650 /* none available, so resize and try again */
5652 return_bitset.resize (return_bitset.size() + 16, false);
5657 Session::mark_send_id (uint32_t id)
5659 if (id >= send_bitset.size()) {
5660 send_bitset.resize (id+16, false);
5662 if (send_bitset[id]) {
5663 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5665 send_bitset[id] = true;
5669 Session::mark_aux_send_id (uint32_t id)
5671 if (id >= aux_send_bitset.size()) {
5672 aux_send_bitset.resize (id+16, false);
5674 if (aux_send_bitset[id]) {
5675 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5677 aux_send_bitset[id] = true;
5681 Session::mark_return_id (uint32_t id)
5683 if (id >= return_bitset.size()) {
5684 return_bitset.resize (id+16, false);
5686 if (return_bitset[id]) {
5687 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5689 return_bitset[id] = true;
5693 Session::mark_insert_id (uint32_t id)
5695 if (id >= insert_bitset.size()) {
5696 insert_bitset.resize (id+16, false);
5698 if (insert_bitset[id]) {
5699 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5701 insert_bitset[id] = true;
5705 Session::unmark_send_id (uint32_t id)
5707 if (id < send_bitset.size()) {
5708 send_bitset[id] = false;
5713 Session::unmark_aux_send_id (uint32_t id)
5715 if (id < aux_send_bitset.size()) {
5716 aux_send_bitset[id] = false;
5721 Session::unmark_return_id (uint32_t id)
5723 if (_state_of_the_state & Deletion) { return; }
5724 if (id < return_bitset.size()) {
5725 return_bitset[id] = false;
5730 Session::unmark_insert_id (uint32_t id)
5732 if (id < insert_bitset.size()) {
5733 insert_bitset[id] = false;
5738 Session::reset_native_file_format ()
5740 boost::shared_ptr<RouteList> rl = routes.reader ();
5742 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5743 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5745 /* don't save state as we do this, there's no point
5747 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5748 tr->reset_write_sources (false);
5749 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5755 Session::route_name_unique (string n) const
5757 boost::shared_ptr<RouteList> r = routes.reader ();
5759 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5760 if ((*i)->name() == n) {
5769 Session::route_name_internal (string n) const
5771 if (auditioner && auditioner->name() == n) {
5775 if (_click_io && _click_io->name() == n) {
5783 Session::freeze_all (InterThreadInfo& itt)
5785 boost::shared_ptr<RouteList> r = routes.reader ();
5787 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5789 boost::shared_ptr<Track> t;
5791 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5792 /* XXX this is wrong because itt.progress will keep returning to zero at the start
5802 boost::shared_ptr<Region>
5803 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5804 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5805 InterThreadInfo& itt,
5806 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5807 bool for_export, bool for_freeze)
5809 boost::shared_ptr<Region> result;
5810 boost::shared_ptr<Playlist> playlist;
5811 boost::shared_ptr<Source> source;
5812 ChanCount diskstream_channels (track.n_channels());
5813 framepos_t position;
5814 framecnt_t this_chunk;
5816 framepos_t latency_skip;
5818 framepos_t len = end - start;
5819 bool need_block_size_reset = false;
5820 ChanCount const max_proc = track.max_processor_streams ();
5821 string legal_playlist_name;
5822 string possible_path;
5825 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5826 end, start) << endmsg;
5830 diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5831 include_endpoint, for_export, for_freeze);
5833 if (diskstream_channels.n(track.data_type()) < 1) {
5834 error << _("Cannot write a range with no data.") << endmsg;
5838 // block all process callback handling
5840 block_processing ();
5843 // synchronize with AudioEngine::process_callback()
5844 // make sure processing is not currently running
5845 // and processing_blocked() is honored before
5846 // acquiring thread buffers
5847 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5850 _bounce_processing_active = true;
5852 /* call tree *MUST* hold route_lock */
5854 if ((playlist = track.playlist()) == 0) {
5858 legal_playlist_name = legalize_for_path (playlist->name());
5860 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5862 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5863 string path = ((track.data_type() == DataType::AUDIO)
5864 ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5865 : new_midi_source_path (legal_playlist_name));
5872 source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5875 catch (failed_constructor& err) {
5876 error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5880 srcs.push_back (source);
5883 /* tell redirects that care that we are about to use a much larger
5884 * blocksize. this will flush all plugins too, so that they are ready
5885 * to be used for this process.
5888 need_block_size_reset = true;
5889 track.set_block_size (bounce_chunk_size);
5890 _engine.main_thread()->get_buffers ();
5894 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5896 /* create a set of reasonably-sized buffers */
5897 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5898 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5900 buffers.set_count (max_proc);
5902 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5903 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5904 boost::shared_ptr<MidiSource> ms;
5906 afs->prepare_for_peakfile_writes ();
5907 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5908 Source::Lock lock(ms->mutex());
5909 ms->mark_streaming_write_started(lock);
5913 while (to_do && !itt.cancel) {
5915 this_chunk = min (to_do, bounce_chunk_size);
5917 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5921 start += this_chunk;
5922 to_do -= this_chunk;
5923 itt.progress = (float) (1.0 - ((double) to_do / len));
5925 if (latency_skip >= bounce_chunk_size) {
5926 latency_skip -= bounce_chunk_size;
5930 const framecnt_t current_chunk = this_chunk - latency_skip;
5933 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5934 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5935 boost::shared_ptr<MidiSource> ms;
5938 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5941 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5942 Source::Lock lock(ms->mutex());
5944 const MidiBuffer& buf = buffers.get_midi(0);
5945 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5946 Evoral::Event<framepos_t> ev = *i;
5947 ev.set_time(ev.time() - position);
5948 ms->append_event_frames(lock, ev, ms->timeline_position());
5955 /* post-roll, pick up delayed processor output */
5956 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5958 while (latency_skip && !itt.cancel) {
5959 this_chunk = min (latency_skip, bounce_chunk_size);
5960 latency_skip -= this_chunk;
5962 buffers.silence (this_chunk, 0);
5963 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5966 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5967 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5970 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5982 xnow = localtime (&now);
5984 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5985 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5986 boost::shared_ptr<MidiSource> ms;
5989 afs->update_header (position, *xnow, now);
5990 afs->flush_header ();
5991 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5992 Source::Lock lock(ms->mutex());
5993 ms->mark_streaming_write_completed(lock);
5997 /* construct a region to represent the bounced material */
6001 plist.add (Properties::start, 0);
6002 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
6003 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
6005 result = RegionFactory::create (srcs, plist);
6011 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6012 (*src)->mark_for_remove ();
6013 (*src)->drop_references ();
6017 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
6018 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
6021 afs->done_with_peakfile_writes ();
6025 _bounce_processing_active = false;
6027 if (need_block_size_reset) {
6028 _engine.main_thread()->drop_buffers ();
6029 track.set_block_size (get_block_size());
6032 unblock_processing ();
6038 Session::gain_automation_buffer() const
6040 return ProcessThread::gain_automation_buffer ();
6044 Session::trim_automation_buffer() const
6046 return ProcessThread::trim_automation_buffer ();
6050 Session::send_gain_automation_buffer() const
6052 return ProcessThread::send_gain_automation_buffer ();
6056 Session::pan_automation_buffer() const
6058 return ProcessThread::pan_automation_buffer ();
6062 Session::get_silent_buffers (ChanCount count)
6064 return ProcessThread::get_silent_buffers (count);
6068 Session::get_scratch_buffers (ChanCount count, bool silence)
6070 return ProcessThread::get_scratch_buffers (count, silence);
6074 Session::get_noinplace_buffers (ChanCount count)
6076 return ProcessThread::get_noinplace_buffers (count);
6080 Session::get_route_buffers (ChanCount count, bool silence)
6082 return ProcessThread::get_route_buffers (count, silence);
6087 Session::get_mix_buffers (ChanCount count)
6089 return ProcessThread::get_mix_buffers (count);
6093 Session::ntracks () const
6096 boost::shared_ptr<RouteList> r = routes.reader ();
6098 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6099 if (boost::dynamic_pointer_cast<Track> (*i)) {
6108 Session::nbusses () const
6111 boost::shared_ptr<RouteList> r = routes.reader ();
6113 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
6114 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
6123 Session::add_automation_list(AutomationList *al)
6125 automation_lists[al->id()] = al;
6128 /** @return true if there is at least one record-enabled track, otherwise false */
6130 Session::have_rec_enabled_track () const
6132 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
6136 Session::have_rec_disabled_track () const
6138 return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
6141 /** Update the state of our rec-enabled tracks flag */
6143 Session::update_route_record_state ()
6145 boost::shared_ptr<RouteList> rl = routes.reader ();
6146 RouteList::iterator i = rl->begin();
6147 while (i != rl->end ()) {
6149 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6150 if (tr && tr->rec_enable_control()->get_value()) {
6157 int const old = g_atomic_int_get (&_have_rec_enabled_track);
6159 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6161 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6162 RecordStateChanged (); /* EMIT SIGNAL */
6165 for (i = rl->begin(); i != rl->end (); ++i) {
6166 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6167 if (tr && !tr->rec_enable_control()->get_value()) {
6172 g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6174 bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6176 if (record_status() == Recording && record_arm_state_changed ) {
6177 RecordArmStateChanged ();
6183 Session::listen_position_changed ()
6185 boost::shared_ptr<RouteList> r = routes.reader ();
6187 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6188 (*i)->listen_position_changed ();
6193 Session::solo_control_mode_changed ()
6195 if (soloing() || listening()) {
6196 /* We can't use ::clear_all_solo_state() here because during
6197 session loading at program startup, that will queue a call
6198 to rt_clear_all_solo_state() that will not execute until
6199 AFTER solo states have been established (thus throwing away
6200 the session's saved solo state). So just explicitly turn
6203 set_controls (route_list_to_control_list (get_routes(), &Stripable::solo_control), 0.0, Controllable::NoGroup);
6207 /** Called when a property of one of our route groups changes */
6209 Session::route_group_property_changed (RouteGroup* rg)
6211 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6214 /** Called when a route is added to one of our route groups */
6216 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6218 RouteAddedToRouteGroup (rg, r);
6221 /** Called when a route is removed from one of our route groups */
6223 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6225 update_route_record_state ();
6226 RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6229 boost::shared_ptr<RouteList>
6230 Session::get_tracks () const
6232 boost::shared_ptr<RouteList> rl = routes.reader ();
6233 boost::shared_ptr<RouteList> tl (new RouteList);
6235 for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6236 if (boost::dynamic_pointer_cast<Track> (*r)) {
6237 if (!(*r)->is_auditioner()) {
6245 boost::shared_ptr<RouteList>
6246 Session::get_routes_with_regions_at (framepos_t const p) const
6248 boost::shared_ptr<RouteList> r = routes.reader ();
6249 boost::shared_ptr<RouteList> rl (new RouteList);
6251 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6252 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6257 boost::shared_ptr<Playlist> pl = tr->playlist ();
6262 if (pl->has_region_at (p)) {
6271 Session::goto_end ()
6273 if (_session_range_location) {
6274 request_locate (_session_range_location->end(), false);
6276 request_locate (0, false);
6281 Session::goto_start ()
6283 if (_session_range_location) {
6284 request_locate (_session_range_location->start(), false);
6286 request_locate (0, false);
6291 Session::current_start_frame () const
6293 return _session_range_location ? _session_range_location->start() : 0;
6297 Session::current_end_frame () const
6299 return _session_range_location ? _session_range_location->end() : 0;
6303 Session::set_session_range_location (framepos_t start, framepos_t end)
6305 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
6306 _locations->add (_session_range_location);
6310 Session::step_edit_status_change (bool yn)
6316 send = (_step_editors == 0);
6321 send = (_step_editors == 1);
6324 if (_step_editors > 0) {
6330 StepEditStatusChange (val);
6336 Session::start_time_changed (framepos_t old)
6338 /* Update the auto loop range to match the session range
6339 (unless the auto loop range has been changed by the user)
6342 Location* s = _locations->session_range_location ();
6347 Location* l = _locations->auto_loop_location ();
6349 if (l && l->start() == old) {
6350 l->set_start (s->start(), true);
6355 Session::end_time_changed (framepos_t old)
6357 /* Update the auto loop range to match the session range
6358 (unless the auto loop range has been changed by the user)
6361 Location* s = _locations->session_range_location ();
6366 Location* l = _locations->auto_loop_location ();
6368 if (l && l->end() == old) {
6369 l->set_end (s->end(), true);
6373 std::vector<std::string>
6374 Session::source_search_path (DataType type) const
6378 if (session_dirs.size() == 1) {
6380 case DataType::AUDIO:
6381 sp.push_back (_session_dir->sound_path());
6383 case DataType::MIDI:
6384 sp.push_back (_session_dir->midi_path());
6388 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6389 SessionDirectory sdir (i->path);
6391 case DataType::AUDIO:
6392 sp.push_back (sdir.sound_path());
6394 case DataType::MIDI:
6395 sp.push_back (sdir.midi_path());
6401 if (type == DataType::AUDIO) {
6402 const string sound_path_2X = _session_dir->sound_path_2X();
6403 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6404 if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6405 sp.push_back (sound_path_2X);
6410 // now check the explicit (possibly user-specified) search path
6413 case DataType::AUDIO:
6414 sp += Searchpath(config.get_audio_search_path ());
6416 case DataType::MIDI:
6417 sp += Searchpath(config.get_midi_search_path ());
6425 Session::ensure_search_path_includes (const string& path, DataType type)
6434 case DataType::AUDIO:
6435 sp += Searchpath(config.get_audio_search_path ());
6437 case DataType::MIDI:
6438 sp += Searchpath (config.get_midi_search_path ());
6442 for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6443 /* No need to add this new directory if it has the same inode as
6444 an existing one; checking inode rather than name prevents duplicated
6445 directories when we are using symlinks.
6447 On Windows, I think we could just do if (*i == path) here.
6449 if (PBD::equivalent_paths (*i, path)) {
6457 case DataType::AUDIO:
6458 config.set_audio_search_path (sp.to_string());
6460 case DataType::MIDI:
6461 config.set_midi_search_path (sp.to_string());
6467 Session::remove_dir_from_search_path (const string& dir, DataType type)
6472 case DataType::AUDIO:
6473 sp = Searchpath(config.get_audio_search_path ());
6475 case DataType::MIDI:
6476 sp = Searchpath (config.get_midi_search_path ());
6483 case DataType::AUDIO:
6484 config.set_audio_search_path (sp.to_string());
6486 case DataType::MIDI:
6487 config.set_midi_search_path (sp.to_string());
6493 boost::shared_ptr<Speakers>
6494 Session::get_speakers()
6500 Session::unknown_processors () const
6504 boost::shared_ptr<RouteList> r = routes.reader ();
6505 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6506 list<string> t = (*i)->unknown_processors ();
6507 copy (t.begin(), t.end(), back_inserter (p));
6517 Session::update_latency (bool playback)
6520 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6522 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _route_deletion_in_progress) {
6526 boost::shared_ptr<RouteList> r = routes.reader ();
6527 framecnt_t max_latency = 0;
6530 /* reverse the list so that we work backwards from the last route to run to the first */
6531 RouteList* rl = routes.reader().get();
6532 r.reset (new RouteList (*rl));
6533 reverse (r->begin(), r->end());
6536 /* compute actual latency values for the given direction and store them all in per-port
6537 structures. this will also publish the same values (to JACK) so that computation of latency
6538 for routes can consistently use public latency values.
6541 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6542 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6545 /* because we latency compensate playback, our published playback latencies should
6546 be the same for all output ports - all material played back by ardour has
6547 the same latency, whether its caused by plugins or by latency compensation. since
6548 these may differ from the values computed above, reset all playback port latencies
6552 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6554 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6555 (*i)->set_public_port_latencies (max_latency, playback);
6560 post_playback_latency ();
6564 post_capture_latency ();
6567 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6571 Session::post_playback_latency ()
6573 set_worst_playback_latency ();
6575 boost::shared_ptr<RouteList> r = routes.reader ();
6577 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6578 if (!(*i)->is_auditioner() && ((*i)->active())) {
6579 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6583 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6584 (*i)->set_latency_compensation (_worst_track_latency);
6589 Session::post_capture_latency ()
6591 set_worst_capture_latency ();
6593 /* reflect any changes in capture latencies into capture offsets
6596 boost::shared_ptr<RouteList> rl = routes.reader();
6597 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6598 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6600 tr->set_capture_offset ();
6606 Session::initialize_latencies ()
6609 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6610 update_latency (false);
6611 update_latency (true);
6614 set_worst_io_latencies ();
6618 Session::set_worst_io_latencies ()
6620 set_worst_playback_latency ();
6621 set_worst_capture_latency ();
6625 Session::set_worst_playback_latency ()
6627 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6631 _worst_output_latency = 0;
6633 if (!_engine.connected()) {
6637 boost::shared_ptr<RouteList> r = routes.reader ();
6639 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6640 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6643 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6647 Session::set_worst_capture_latency ()
6649 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6653 _worst_input_latency = 0;
6655 if (!_engine.connected()) {
6659 boost::shared_ptr<RouteList> r = routes.reader ();
6661 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6662 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6665 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6669 Session::update_latency_compensation (bool force_whole_graph)
6671 bool some_track_latency_changed = false;
6673 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6677 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6679 _worst_track_latency = 0;
6681 boost::shared_ptr<RouteList> r = routes.reader ();
6683 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6684 if (!(*i)->is_auditioner() && ((*i)->active())) {
6686 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6687 some_track_latency_changed = true;
6689 _worst_track_latency = max (tl, _worst_track_latency);
6693 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6694 (some_track_latency_changed ? "yes" : "no")));
6696 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6698 if (some_track_latency_changed || force_whole_graph) {
6699 _engine.update_latencies ();
6703 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6704 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6708 tr->set_capture_offset ();
6713 Session::session_name_is_legal (const string& path)
6715 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6717 for (int i = 0; illegal_chars[i]; ++i) {
6718 if (path.find (illegal_chars[i]) != string::npos) {
6719 return illegal_chars[i];
6727 Session::notify_presentation_info_change ()
6729 if (deletion_in_progress()) {
6733 PresentationInfo::Change (); /* EMIT SIGNAL */
6734 reassign_track_numbers();
6736 #ifdef USE_TRACKS_CODE_FEATURES
6737 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6738 * if track order has been changed by user
6740 reconnect_existing_routes(true, true);
6746 Session::operation_in_progress (GQuark op) const
6748 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6751 boost::shared_ptr<Port>
6752 Session::ltc_input_port () const
6754 return _ltc_input->nth (0);
6757 boost::shared_ptr<Port>
6758 Session::ltc_output_port () const
6760 return _ltc_output->nth (0);
6764 Session::reconnect_ltc_input ()
6768 string src = Config->get_ltc_source_port();
6770 _ltc_input->disconnect (this);
6772 if (src != _("None") && !src.empty()) {
6773 _ltc_input->nth (0)->connect (src);
6776 if ( ARDOUR::Profile->get_trx () ) {
6777 // Tracks need this signal to update timecode_source_dropdown
6778 MtcOrLtcInputPortChanged (); //emit signal
6784 Session::reconnect_ltc_output ()
6788 string src = Config->get_ltc_output_port();
6790 _ltc_output->disconnect (this);
6792 if (src != _("None") && !src.empty()) {
6793 _ltc_output->nth (0)->connect (src);
6799 Session::set_range_selection (framepos_t start, framepos_t end)
6801 _range_selection = Evoral::Range<framepos_t> (start, end);
6802 #ifdef USE_TRACKS_CODE_FEATURES
6803 follow_playhead_priority ();
6808 Session::set_object_selection (framepos_t start, framepos_t end)
6810 _object_selection = Evoral::Range<framepos_t> (start, end);
6811 #ifdef USE_TRACKS_CODE_FEATURES
6812 follow_playhead_priority ();
6817 Session::clear_range_selection ()
6819 _range_selection = Evoral::Range<framepos_t> (-1,-1);
6820 #ifdef USE_TRACKS_CODE_FEATURES
6821 follow_playhead_priority ();
6826 Session::clear_object_selection ()
6828 _object_selection = Evoral::Range<framepos_t> (-1,-1);
6829 #ifdef USE_TRACKS_CODE_FEATURES
6830 follow_playhead_priority ();
6835 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
6836 const ChanCount& input_start,
6837 const ChanCount& output_start,
6838 const ChanCount& input_offset,
6839 const ChanCount& output_offset)
6841 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6842 _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
6843 input_start, output_start,
6844 input_offset, output_offset));
6846 if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
6847 pthread_cond_signal (&_auto_connect_cond);
6848 pthread_mutex_unlock (&_auto_connect_mutex);
6853 Session::queue_latency_recompute ()
6855 g_atomic_int_inc (&_latency_recompute_pending);
6856 if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
6857 pthread_cond_signal (&_auto_connect_cond);
6858 pthread_mutex_unlock (&_auto_connect_mutex);
6863 Session::auto_connect (const AutoConnectRequest& ar)
6865 boost::shared_ptr<Route> route = ar.route.lock();
6867 if (!route) { return; }
6869 if (!IO::connecting_legal) {
6873 /* If both inputs and outputs are auto-connected to physical ports,
6874 * use the max of input and output offsets to ensure auto-connected
6875 * port numbers always match up (e.g. the first audio input and the
6876 * first audio output of the route will have the same physical
6877 * port number). Otherwise just use the lowest input or output
6881 const bool in_out_physical =
6882 (Config->get_input_auto_connect() & AutoConnectPhysical)
6883 && (Config->get_output_auto_connect() & AutoConnectPhysical)
6884 && ar.connect_inputs;
6886 const ChanCount in_offset = in_out_physical
6887 ? ChanCount::max(ar.input_offset, ar.output_offset)
6890 const ChanCount out_offset = in_out_physical
6891 ? ChanCount::max(ar.input_offset, ar.output_offset)
6894 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6895 vector<string> physinputs;
6896 vector<string> physoutputs;
6898 _engine.get_physical_outputs (*t, physoutputs);
6899 _engine.get_physical_inputs (*t, physinputs);
6901 if (!physinputs.empty() && ar.connect_inputs) {
6902 uint32_t nphysical_in = physinputs.size();
6904 for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
6907 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
6908 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
6911 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
6917 if (!physoutputs.empty()) {
6918 uint32_t nphysical_out = physoutputs.size();
6919 for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
6923 * do not create new connections if we reached the limit of physical outputs
6926 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
6927 ARDOUR::Profile->get_trx () &&
6928 ar.output_offset.get(*t) == nphysical_out ) {
6932 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
6933 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
6934 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
6935 /* master bus is audio only */
6936 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
6937 port = _master_out->input()->ports().port(*t,
6938 i % _master_out->input()->n_ports().get(*t))->name();
6942 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
6951 Session::auto_connect_thread_start ()
6953 if (_ac_thread_active) {
6957 while (!_auto_connect_queue.empty ()) {
6958 _auto_connect_queue.pop ();
6961 _ac_thread_active = true;
6962 if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
6963 _ac_thread_active = false;
6968 Session::auto_connect_thread_terminate ()
6970 if (!_ac_thread_active) {
6973 _ac_thread_active = false;
6976 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6977 while (!_auto_connect_queue.empty ()) {
6978 _auto_connect_queue.pop ();
6982 if (pthread_mutex_lock (&_auto_connect_mutex) == 0) {
6983 pthread_cond_signal (&_auto_connect_cond);
6984 pthread_mutex_unlock (&_auto_connect_mutex);
6988 pthread_join (_auto_connect_thread, &status);
6992 Session::auto_connect_thread (void *arg)
6994 Session *s = static_cast<Session *>(arg);
6995 s->auto_connect_thread_run ();
7001 Session::auto_connect_thread_run ()
7003 pthread_set_name (X_("autoconnect"));
7004 SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
7005 PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
7006 pthread_mutex_lock (&_auto_connect_mutex);
7007 while (_ac_thread_active) {
7009 if (!_auto_connect_queue.empty ()) {
7010 // Why would we need the process lock ??
7011 // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
7012 // graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
7013 // All ardour-internal backends use a std::vector xxxAudioBackend::find_port()
7014 // We have control over those, but what does jack do?
7015 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
7017 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
7018 while (!_auto_connect_queue.empty ()) {
7019 const AutoConnectRequest ar (_auto_connect_queue.front());
7020 _auto_connect_queue.pop ();
7027 if (!actively_recording ()) { // might not be needed,
7028 /* this is only used for updating plugin latencies, the
7029 * graph does not change. so it's safe in general.
7031 * .. update_latency_compensation () entails set_capture_offset()
7032 * which calls Diskstream::set_capture_offset () which
7033 * modifies the capture offset... which can be a proplem
7034 * in "prepare_to_stop"
7036 while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
7037 update_latency_compensation ();
7041 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
7043 pthread_mutex_unlock (&_auto_connect_mutex);
7047 Session::cancel_all_solo ()
7051 get_stripables (sl);
7053 set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
7054 clear_all_solo_state (routes.reader());