2 Copyright (C) 1999-2010 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <cstdio> /* sprintf(3) ... grrr */
33 #include <glibmm/thread.h>
34 #include <glibmm/miscutils.h>
35 #include <glibmm/fileutils.h>
37 #include <boost/algorithm/string/erase.hpp>
39 #include "pbd/error.h"
40 #include "pbd/boost_debug.h"
41 #include "pbd/pathscanner.h"
42 #include "pbd/stl_delete.h"
43 #include "pbd/basename.h"
44 #include "pbd/stacktrace.h"
45 #include "pbd/file_utils.h"
46 #include "pbd/convert.h"
47 #include "pbd/strsplit.h"
49 #include "ardour/amp.h"
50 #include "ardour/analyser.h"
51 #include "ardour/audio_buffer.h"
52 #include "ardour/audio_diskstream.h"
53 #include "ardour/audio_port.h"
54 #include "ardour/audio_track.h"
55 #include "ardour/audioengine.h"
56 #include "ardour/audiofilesource.h"
57 #include "ardour/audioplaylist.h"
58 #include "ardour/audioregion.h"
59 #include "ardour/auditioner.h"
60 #include "ardour/buffer_manager.h"
61 #include "ardour/buffer_set.h"
62 #include "ardour/bundle.h"
63 #include "ardour/butler.h"
64 #include "ardour/click.h"
65 #include "ardour/configuration.h"
66 #include "ardour/control_protocol_manager.h"
67 #include "ardour/crossfade.h"
68 #include "ardour/cycle_timer.h"
69 #include "ardour/data_type.h"
70 #include "ardour/debug.h"
71 #include "ardour/filename_extensions.h"
72 #include "ardour/internal_send.h"
73 #include "ardour/io_processor.h"
74 #include "ardour/midi_diskstream.h"
75 #include "ardour/midi_playlist.h"
76 #include "ardour/midi_region.h"
77 #include "ardour/midi_track.h"
78 #include "ardour/midi_ui.h"
79 #include "ardour/named_selection.h"
80 #include "ardour/process_thread.h"
81 #include "ardour/playlist.h"
82 #include "ardour/plugin_insert.h"
83 #include "ardour/port_insert.h"
84 #include "ardour/processor.h"
85 #include "ardour/rc_configuration.h"
86 #include "ardour/recent_sessions.h"
87 #include "ardour/region_factory.h"
88 #include "ardour/return.h"
89 #include "ardour/route_group.h"
90 #include "ardour/send.h"
91 #include "ardour/session.h"
92 #include "ardour/session_directory.h"
93 #include "ardour/session_directory.h"
94 #include "ardour/session_metadata.h"
95 #include "ardour/session_playlists.h"
96 #include "ardour/slave.h"
97 #include "ardour/smf_source.h"
98 #include "ardour/source_factory.h"
99 #include "ardour/tape_file_matcher.h"
100 #include "ardour/tempo.h"
101 #include "ardour/utils.h"
102 #include "ardour/graph.h"
103 #include "ardour/speakers.h"
104 #include "ardour/operations.h"
106 #include "midi++/port.h"
107 #include "midi++/mmc.h"
108 #include "midi++/manager.h"
113 using namespace ARDOUR;
116 bool Session::_disable_all_loaded_plugins = false;
118 PBD::Signal1<void,std::string> Session::Dialog;
119 PBD::Signal0<int> Session::AskAboutPendingState;
120 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
121 PBD::Signal0<void> Session::SendFeedback;
122 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
124 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
125 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
126 PBD::Signal0<void> Session::AutoBindingOn;
127 PBD::Signal0<void> Session::AutoBindingOff;
128 PBD::Signal2<void,std::string, std::string> Session::Exported;
129 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
130 PBD::Signal0<void> Session::Quit;
132 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
133 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
135 /** @param snapshot_name Snapshot name, without .ardour prefix */
136 Session::Session (AudioEngine &eng,
137 const string& fullpath,
138 const string& snapshot_name,
139 BusProfile* bus_profile,
142 , _target_transport_speed (0.0)
143 , _requested_return_frame (-1)
144 , _session_dir (new SessionDirectory(fullpath))
146 , _state_of_the_state (Clean)
147 , _butler (new Butler (*this))
148 , _post_transport_work (0)
149 , _send_timecode_update (false)
150 , _all_route_group (new RouteGroup (*this, "all"))
151 , route_graph (new Graph(*this))
152 , routes (new RouteList)
153 , _total_free_4k_blocks (0)
154 , _bundles (new BundleList)
155 , _bundle_xml_node (0)
157 , _click_io ((IO*) 0)
159 , click_emphasis_data (0)
161 , _metadata (new SessionMetadata())
162 , _have_rec_enabled_track (false)
163 , _suspend_timecode_transmission (0)
165 _locations = new Locations (*this);
167 playlists.reset (new SessionPlaylists);
169 _all_route_group->set_active (true, this);
171 interpolation.add_channel_to (0, 0);
173 if (!eng.connected()) {
174 throw failed_constructor();
177 n_physical_outputs = _engine.n_physical_outputs ();
178 n_physical_inputs = _engine.n_physical_inputs ();
180 first_stage_init (fullpath, snapshot_name);
182 _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
185 if (create (mix_template, bus_profile)) {
187 throw failed_constructor ();
191 if (second_stage_init ()) {
193 throw failed_constructor ();
196 store_recent_sessions(_name, _path);
198 bool was_dirty = dirty();
200 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
202 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
203 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
206 DirtyChanged (); /* EMIT SIGNAL */
209 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
210 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
223 vector<void*> debug_pointers;
225 /* if we got to here, leaving pending capture state around
229 remove_pending_capture_state ();
231 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
233 _engine.remove_session ();
235 /* clear history so that no references to objects are held any more */
239 /* clear state tree so that no references to objects are held any more */
243 /* reset dynamic state version back to default */
245 Stateful::loading_state_version = 0;
247 _butler->drop_references ();
249 delete midi_control_ui;
250 delete _all_route_group;
252 if (click_data != default_click) {
253 delete [] click_data;
256 if (click_emphasis_data != default_click_emphasis) {
257 delete [] click_emphasis_data;
262 /* clear out any pending dead wood from RCU managed objects */
267 AudioDiskstream::free_working_buffers();
269 /* tell everyone who is still standing that we're about to die */
272 /* tell everyone to drop references and delete objects as we go */
274 DEBUG_TRACE (DEBUG::Destruction, "delete named selections\n");
275 named_selections.clear ();
277 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
278 RegionFactory::delete_all_regions ();
280 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
282 /* reset these three references to special routes before we do the usual route delete thing */
285 _master_out.reset ();
286 _monitor_out.reset ();
289 RCUWriter<RouteList> writer (routes);
290 boost::shared_ptr<RouteList> r = writer.get_copy ();
292 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
293 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
294 (*i)->drop_references ();
298 /* writer goes out of scope and updates master */
302 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
303 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
304 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
305 i->second->drop_references ();
310 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
311 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
316 Crossfade::set_buffer_size (0);
318 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
323 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
325 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
326 boost_debug_list_ptrs ();
331 Session::when_engine_running ()
333 string first_physical_output;
335 BootMessage (_("Set block size and sample rate"));
337 set_block_size (_engine.frames_per_cycle());
338 set_frame_rate (_engine.frame_rate());
340 BootMessage (_("Using configuration"));
342 boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
343 boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
345 Config->map_parameters (ff);
346 config.map_parameters (ft);
348 /* every time we reconnect, recompute worst case output latencies */
350 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
352 if (synced_to_jack()) {
353 _engine.transport_stop ();
356 if (config.get_jack_time_master()) {
357 _engine.transport_locate (_transport_frame);
365 _click_io.reset (new ClickIO (*this, "click"));
367 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
369 /* existing state for Click */
372 if (Stateful::loading_state_version < 3000) {
373 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
375 c = _click_io->set_state (*child->children().front(), Stateful::loading_state_version);
380 _clicking = Config->get_clicking ();
384 error << _("could not setup Click I/O") << endmsg;
391 /* default state for Click: dual-mono to first 2 physical outputs */
394 _engine.get_physical_outputs (DataType::AUDIO, outs);
396 for (uint32_t physport = 0; physport < 2; ++physport) {
397 if (outs.size() > physport) {
398 if (_click_io->add_port (outs[physport], this)) {
399 // relax, even though its an error
404 if (_click_io->n_ports () > ChanCount::ZERO) {
405 _clicking = Config->get_clicking ();
410 catch (failed_constructor& err) {
411 error << _("cannot setup Click I/O") << endmsg;
414 BootMessage (_("Compute I/O Latencies"));
417 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
420 BootMessage (_("Set up standard connections"));
422 vector<string> inputs[DataType::num_types];
423 vector<string> outputs[DataType::num_types];
424 for (uint32_t i = 0; i < DataType::num_types; ++i) {
425 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
426 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
429 /* Create a set of Bundle objects that map
430 to the physical I/O currently available. We create both
431 mono and stereo bundles, so that the common cases of mono
432 and stereo tracks get bundles to put in their mixer strip
433 in / out menus. There may be a nicer way of achieving that;
434 it doesn't really scale that well to higher channel counts
437 /* mono output bundles */
439 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
441 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
443 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
444 c->add_channel (_("mono"), DataType::AUDIO);
445 c->set_port (0, outputs[DataType::AUDIO][np]);
450 /* stereo output bundles */
452 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
453 if (np + 1 < outputs[DataType::AUDIO].size()) {
455 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
456 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
457 c->add_channel (_("L"), DataType::AUDIO);
458 c->set_port (0, outputs[DataType::AUDIO][np]);
459 c->add_channel (_("R"), DataType::AUDIO);
460 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
466 /* mono input bundles */
468 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
470 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
472 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
473 c->add_channel (_("mono"), DataType::AUDIO);
474 c->set_port (0, inputs[DataType::AUDIO][np]);
479 /* stereo input bundles */
481 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
482 if (np + 1 < inputs[DataType::AUDIO].size()) {
484 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
486 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
487 c->add_channel (_("L"), DataType::AUDIO);
488 c->set_port (0, inputs[DataType::AUDIO][np]);
489 c->add_channel (_("R"), DataType::AUDIO);
490 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
496 /* MIDI input bundles */
498 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
499 string n = inputs[DataType::MIDI][np];
500 boost::erase_first (n, X_("alsa_pcm:"));
502 boost::shared_ptr<Bundle> c (new Bundle (n, false));
503 c->add_channel ("", DataType::MIDI);
504 c->set_port (0, inputs[DataType::MIDI][np]);
508 /* MIDI output bundles */
510 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
511 string n = outputs[DataType::MIDI][np];
512 boost::erase_first (n, X_("alsa_pcm:"));
514 boost::shared_ptr<Bundle> c (new Bundle (n, true));
515 c->add_channel ("", DataType::MIDI);
516 c->set_port (0, outputs[DataType::MIDI][np]);
520 BootMessage (_("Setup signal flow and plugins"));
522 ControlProtocolManager::instance().set_session (this);
524 /* This must be done after the ControlProtocolManager set_session above,
525 as it will set states for ports which the ControlProtocolManager creates.
527 MIDI::Manager::instance()->set_port_states (Config->midi_port_states ());
529 /* And this must be done after the MIDI::Manager::set_port_states as
530 * it will try to make connections whose details are loaded by set_port_states.
535 if (_is_new && !no_auto_connect()) {
537 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
539 /* don't connect the master bus outputs if there is a monitor bus */
541 if (_master_out && Config->get_auto_connect_standard_busses() && !_monitor_out) {
543 /* if requested auto-connect the outputs to the first N physical ports.
546 uint32_t limit = _master_out->n_outputs().n_total();
548 for (uint32_t n = 0; n < limit; ++n) {
549 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
551 if (outputs[p->type()].size() > n) {
552 connect_to = outputs[p->type()][n];
555 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
556 if (_master_out->output()->connect (p, connect_to, this)) {
557 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
567 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
568 are undefined, at best.
571 /* control out listens to master bus (but ignores it
572 under some conditions)
575 uint32_t limit = _monitor_out->n_inputs().n_audio();
578 for (uint32_t n = 0; n < limit; ++n) {
579 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
580 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
583 string connect_to = o->name();
584 if (_monitor_out->input()->connect (p, connect_to, this)) {
585 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
593 /* if control out is not connected, connect control out to physical outs
596 if (!_monitor_out->output()->connected ()) {
598 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
600 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
603 _monitor_out->output()->connect_ports_to_bundle (b, this);
605 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
606 Config->get_monitor_bus_preferred_bundle())
612 /* Monitor bus is audio only */
613 uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
614 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
618 for (uint32_t n = 0; n < limit; ++n) {
620 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
622 if (outputs[DataType::AUDIO].size() > (n % mod)) {
623 connect_to = outputs[DataType::AUDIO][n % mod];
626 if (!connect_to.empty()) {
627 if (_monitor_out->output()->connect (p, connect_to, this)) {
628 error << string_compose (
629 _("cannot connect control output %1 to %2"),
642 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
644 /* update latencies */
646 initialize_latencies ();
648 /* hook us up to the engine */
650 BootMessage (_("Connect to engine"));
651 _engine.set_session (this);
655 Session::hookup_io ()
657 /* stop graph reordering notifications from
658 causing resorts, etc.
661 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
665 /* we delay creating the auditioner till now because
666 it makes its own connections to ports.
670 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
672 throw failed_constructor ();
674 a->use_new_diskstream ();
678 catch (failed_constructor& err) {
679 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
683 /* load bundles, which we may have postponed earlier on */
684 if (_bundle_xml_node) {
685 load_bundles (*_bundle_xml_node);
686 delete _bundle_xml_node;
689 /* Tell all IO objects to connect themselves together */
691 IO::enable_connecting ();
692 MIDI::Port::MakeConnections ();
694 /* Now reset all panners */
696 Delivery::reset_panners ();
698 /* Connect tracks to monitor/listen bus if there is one. Note that in an
699 existing session, the internal sends will already exist, but we want the
700 routes to notice that they connect to the control out specifically.
704 boost::shared_ptr<RouteList> r = routes.reader ();
705 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
707 if ((*x)->is_monitor()) {
711 } else if ((*x)->is_master()) {
717 (*x)->listen_via_monitor ();
722 /* Anyone who cares about input state, wake up and do something */
724 IOConnectionsComplete (); /* EMIT SIGNAL */
726 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
728 /* now handle the whole enchilada as if it was one
734 /* update the full solo state, which can't be
735 correctly determined on a per-route basis, but
736 needs the global overview that only the session
740 update_route_solo_state ();
744 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
746 boost::shared_ptr<Track> track = wp.lock ();
751 boost::shared_ptr<Playlist> playlist;
753 if ((playlist = track->playlist()) != 0) {
754 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
755 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
756 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
761 Session::record_enabling_legal () const
763 /* this used to be in here, but survey says.... we don't need to restrict it */
764 // if (record_status() == Recording) {
768 if (Config->get_all_safe()) {
775 Session::set_track_monitor_input_status (bool yn)
777 boost::shared_ptr<RouteList> rl = routes.reader ();
778 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
779 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
780 if (tr && tr->record_enabled ()) {
781 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
782 tr->monitor_input (yn);
788 Session::reset_input_monitor_state ()
790 if (transport_rolling()) {
791 set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
793 set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring);
798 Session::auto_punch_start_changed (Location* location)
800 replace_event (SessionEvent::PunchIn, location->start());
802 if (get_record_enabled() && config.get_punch_in()) {
803 /* capture start has been changed, so save new pending state */
804 save_state ("", true);
809 Session::auto_punch_end_changed (Location* location)
811 framepos_t when_to_stop = location->end();
812 // when_to_stop += _worst_output_latency + _worst_input_latency;
813 replace_event (SessionEvent::PunchOut, when_to_stop);
817 Session::auto_punch_changed (Location* location)
819 framepos_t when_to_stop = location->end();
821 replace_event (SessionEvent::PunchIn, location->start());
822 //when_to_stop += _worst_output_latency + _worst_input_latency;
823 replace_event (SessionEvent::PunchOut, when_to_stop);
827 Session::auto_loop_changed (Location* location)
829 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
831 if (transport_rolling() && play_loop) {
834 // if (_transport_frame > location->end()) {
836 if (_transport_frame < location->start() || _transport_frame > location->end()) {
837 // relocate to beginning of loop
838 clear_events (SessionEvent::LocateRoll);
840 request_locate (location->start(), true);
843 else if (Config->get_seamless_loop() && !loop_changing) {
845 // schedule a locate-roll to refill the diskstreams at the
847 loop_changing = true;
849 if (location->end() > last_loopend) {
850 clear_events (SessionEvent::LocateRoll);
851 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
858 last_loopend = location->end();
862 Session::set_auto_punch_location (Location* location)
866 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
867 punch_connections.drop_connections();
868 existing->set_auto_punch (false, this);
869 remove_event (existing->start(), SessionEvent::PunchIn);
870 clear_events (SessionEvent::PunchOut);
871 auto_punch_location_changed (0);
880 if (location->end() <= location->start()) {
881 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
885 punch_connections.drop_connections ();
887 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
888 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
889 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
891 location->set_auto_punch (true, this);
893 auto_punch_changed (location);
895 auto_punch_location_changed (location);
899 Session::set_auto_loop_location (Location* location)
903 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
904 loop_connections.drop_connections ();
905 existing->set_auto_loop (false, this);
906 remove_event (existing->end(), SessionEvent::AutoLoop);
907 auto_loop_location_changed (0);
916 if (location->end() <= location->start()) {
917 error << _("Session: you can't use a mark for auto loop") << endmsg;
921 last_loopend = location->end();
923 loop_connections.drop_connections ();
925 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
926 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
927 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
929 location->set_auto_loop (true, this);
931 /* take care of our stuff first */
933 auto_loop_changed (location);
935 /* now tell everyone else */
937 auto_loop_location_changed (location);
941 Session::locations_added (Location *)
947 Session::locations_changed ()
949 _locations->apply (*this, &Session::handle_locations_changed);
953 Session::handle_locations_changed (Locations::LocationList& locations)
955 Locations::LocationList::iterator i;
957 bool set_loop = false;
958 bool set_punch = false;
960 for (i = locations.begin(); i != locations.end(); ++i) {
964 if (location->is_auto_punch()) {
965 set_auto_punch_location (location);
968 if (location->is_auto_loop()) {
969 set_auto_loop_location (location);
973 if (location->is_session_range()) {
974 _session_range_location = location;
979 set_auto_loop_location (0);
982 set_auto_punch_location (0);
989 Session::enable_record ()
991 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
992 /* no recording at anything except normal speed */
997 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
999 if (rs == Recording) {
1003 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1005 _last_record_location = _transport_frame;
1006 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1008 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1009 set_track_monitor_input_status (true);
1012 RecordStateChanged ();
1019 Session::disable_record (bool rt_context, bool force)
1023 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1025 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1026 g_atomic_int_set (&_record_status, Disabled);
1027 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1029 if (rs == Recording) {
1030 g_atomic_int_set (&_record_status, Enabled);
1034 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1035 set_track_monitor_input_status (false);
1038 RecordStateChanged (); /* emit signal */
1041 remove_pending_capture_state ();
1047 Session::step_back_from_record ()
1049 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1051 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1052 set_track_monitor_input_status (false);
1055 RecordStateChanged (); /* emit signal */
1060 Session::maybe_enable_record ()
1062 if (_step_editors > 0) {
1066 g_atomic_int_set (&_record_status, Enabled);
1068 /* This function is currently called from somewhere other than an RT thread.
1069 This save_state() call therefore doesn't impact anything. Doing it here
1070 means that we save pending state of which sources the next record will use,
1071 which gives us some chance of recovering from a crash during the record.
1074 save_state ("", true);
1076 if (_transport_speed) {
1077 if (!config.get_punch_in()) {
1081 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1082 RecordStateChanged (); /* EMIT SIGNAL */
1089 Session::audible_frame () const
1095 /* the first of these two possible settings for "offset"
1096 mean that the audible frame is stationary until
1097 audio emerges from the latency compensation
1100 the second means that the audible frame is stationary
1101 until audio would emerge from a physical port
1102 in the absence of any plugin latency compensation
1105 offset = worst_playback_latency ();
1107 if (offset > current_block_size) {
1108 offset -= current_block_size;
1110 /* XXX is this correct? if we have no external
1111 physical connections and everything is internal
1112 then surely this is zero? still, how
1113 likely is that anyway?
1115 offset = current_block_size;
1118 if (synced_to_jack()) {
1119 tf = _engine.transport_frame();
1121 tf = _transport_frame;
1126 if (!non_realtime_work_pending()) {
1130 /* Check to see if we have passed the first guaranteed
1131 audible frame past our last start position. if not,
1132 return that last start point because in terms
1133 of audible frames, we have not moved yet.
1135 `Start position' in this context means the time we last
1136 either started or changed transport direction.
1139 if (_transport_speed > 0.0f) {
1141 if (!play_loop || !have_looped) {
1142 if (tf < _last_roll_or_reversal_location + offset) {
1143 return _last_roll_or_reversal_location;
1151 } else if (_transport_speed < 0.0f) {
1153 /* XXX wot? no backward looping? */
1155 if (tf > _last_roll_or_reversal_location - offset) {
1156 return _last_roll_or_reversal_location;
1168 Session::set_frame_rate (framecnt_t frames_per_second)
1170 /** \fn void Session::set_frame_size(framecnt_t)
1171 the AudioEngine object that calls this guarantees
1172 that it will not be called while we are also in
1173 ::process(). Its fine to do things that block
1177 _base_frame_rate = frames_per_second;
1181 Automatable::set_automation_interval (ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
1185 // XXX we need some equivalent to this, somehow
1186 // SndFileSource::setup_standard_crossfades (frames_per_second);
1190 /* XXX need to reset/reinstantiate all LADSPA plugins */
1194 Session::set_block_size (pframes_t nframes)
1196 /* the AudioEngine guarantees
1197 that it will not be called while we are also in
1198 ::process(). It is therefore fine to do things that block
1203 current_block_size = nframes;
1207 boost::shared_ptr<RouteList> r = routes.reader ();
1209 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1210 (*i)->set_block_size (nframes);
1213 boost::shared_ptr<RouteList> rl = routes.reader ();
1214 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1215 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1217 tr->set_block_size (nframes);
1221 set_worst_io_latencies ();
1225 struct RouteSorter {
1226 /** @return true to run r1 before r2, otherwise false */
1227 bool sort_by_rec_enabled (const boost::shared_ptr<Route>& r1, const boost::shared_ptr<Route>& r2) {
1228 if (r1->record_enabled()) {
1229 if (r2->record_enabled()) {
1230 /* both rec-enabled, just use signal order */
1231 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1233 /* r1 rec-enabled, r2 not rec-enabled, run r2 early */
1237 if (r2->record_enabled()) {
1238 /* r2 rec-enabled, r1 not rec-enabled, run r1 early */
1241 /* neither rec-enabled, use signal order */
1242 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1247 bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
1248 if (r2->feeds (r1)) {
1249 /* r1 fed by r2; run r2 early */
1251 } else if (r1->feeds (r2)) {
1252 /* r2 fed by r1; run r1 early */
1255 if (r1->not_fed ()) {
1256 if (r2->not_fed ()) {
1257 /* no ardour-based connections inbound to either route. */
1258 return sort_by_rec_enabled (r1, r2);
1260 /* r2 has connections, r1 does not; run r1 early */
1264 if (r2->not_fed()) {
1265 /* r1 has connections, r2 does not; run r2 early */
1268 /* both r1 and r2 have connections, but not to each other. just use signal order */
1269 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1277 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1279 boost::shared_ptr<Route> r2;
1281 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1282 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1286 /* make a copy of the existing list of routes that feed r1 */
1288 Route::FedBy existing (r1->fed_by());
1290 /* for each route that feeds r1, recurse, marking it as feeding
1294 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1295 if (!(r2 = i->r.lock ())) {
1296 /* (*i) went away, ignore it */
1300 /* r2 is a route that feeds r1 which somehow feeds base. mark
1301 base as being fed by r2
1304 rbase->add_fed_by (r2, i->sends_only);
1308 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1312 if (r1->feeds (r2) && r2->feeds (r1)) {
1316 /* now recurse, so that we can mark base as being fed by
1317 all routes that feed r2
1320 trace_terminal (r2, rbase);
1327 Session::resort_routes ()
1329 /* don't do anything here with signals emitted
1330 by Routes during initial setup or while we
1331 are being destroyed.
1334 if (_state_of_the_state & (InitialConnecting | Deletion)) {
1339 RCUWriter<RouteList> writer (routes);
1340 boost::shared_ptr<RouteList> r = writer.get_copy ();
1341 resort_routes_using (r);
1342 /* writer goes out of scope and forces update */
1345 //route_graph->dump(1);
1348 boost::shared_ptr<RouteList> rl = routes.reader ();
1349 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1350 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1352 const Route::FedBy& fb ((*i)->fed_by());
1354 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1355 boost::shared_ptr<Route> sf = f->r.lock();
1357 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1365 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1367 RouteList::iterator i, j;
1369 for (i = r->begin(); i != r->end(); ++i) {
1371 (*i)->clear_fed_by ();
1373 for (j = r->begin(); j != r->end(); ++j) {
1375 /* although routes can feed themselves, it will
1376 cause an endless recursive descent if we
1377 detect it. so don't bother checking for
1385 bool via_sends_only;
1387 if ((*j)->direct_feeds (*i, &via_sends_only)) {
1388 (*i)->add_fed_by (*j, via_sends_only);
1393 for (i = r->begin(); i != r->end(); ++i) {
1394 trace_terminal (*i, *i);
1400 route_graph->rechain (r);
1403 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1404 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1405 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1406 (*i)->name(), (*i)->order_key ("signal")));
1412 /** Find a route name starting with \a base, maybe followed by the
1413 * lowest \a id. \a id will always be added if \a definitely_add_number
1414 * is true on entry; otherwise it will only be added if required
1415 * to make the name unique.
1417 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1418 * The available route name with the lowest ID will be used, and \a id
1419 * will be set to the ID.
1421 * \return false if a route name could not be found, and \a track_name
1422 * and \a id do not reflect a free route name.
1425 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1427 if (!definitely_add_number && route_by_name (base) == 0) {
1428 /* juse use the base */
1429 snprintf (name, name_len, "%s", base.c_str());
1434 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1436 if (route_by_name (name) == 0) {
1442 } while (id < (UINT_MAX-1));
1447 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1449 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1451 in = ChanCount::ZERO;
1452 out = ChanCount::ZERO;
1454 boost::shared_ptr<RouteList> r = routes.reader ();
1456 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1457 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1458 if (tr && !tr->is_hidden()) {
1459 in += tr->n_inputs();
1460 out += tr->n_outputs();
1465 /** Caller must not hold process lock
1466 * @param name_template string to use for the start of the name, or "" to use "Midi".
1468 list<boost::shared_ptr<MidiTrack> >
1469 Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1471 char track_name[32];
1472 uint32_t track_id = 0;
1474 RouteList new_routes;
1475 list<boost::shared_ptr<MidiTrack> > ret;
1476 uint32_t control_id;
1478 control_id = ntracks() + nbusses();
1480 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi");
1483 if (!find_route_name (name_template.empty() ? _("Midi") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1484 error << "cannot find name for new midi track" << endmsg;
1488 boost::shared_ptr<MidiTrack> track;
1491 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1493 if (track->init ()) {
1497 track->use_new_diskstream();
1499 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1500 boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1503 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1504 if (track->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
1505 error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
1509 if (track->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
1510 error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
1515 track->non_realtime_input_change();
1518 route_group->add (track);
1521 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1522 track->set_remote_control_id (control_id);
1524 new_routes.push_back (track);
1525 ret.push_back (track);
1528 catch (failed_constructor &err) {
1529 error << _("Session: could not create new midi track.") << endmsg;
1533 catch (AudioEngine::PortRegistrationFailure& pfe) {
1535 error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
1543 if (!new_routes.empty()) {
1544 add_routes (new_routes, true, true);
1551 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1553 boost::shared_ptr<Route> midi_track (wmt.lock());
1559 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1561 if (change.after.n_audio() <= change.before.n_audio()) {
1565 /* new audio ports: make sure the audio goes somewhere useful,
1566 unless the user has no-auto-connect selected.
1568 The existing ChanCounts don't matter for this call as they are only
1569 to do with matching input and output indices, and we are only changing
1575 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1579 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1580 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1581 * @param output_start As \a input_start, but for outputs.
1584 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1585 bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1587 if (!IO::connecting_legal) {
1591 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
1597 /* If both inputs and outputs are auto-connected to physical ports,
1598 use the max of input and output offsets to ensure auto-connected
1599 port numbers always match up (e.g. the first audio input and the
1600 first audio output of the route will have the same physical
1601 port number). Otherwise just use the lowest input or output
1605 DEBUG_TRACE (DEBUG::Graph,
1606 string_compose("Auto-connect: existing in = %1 out = %2\n",
1607 existing_inputs, existing_outputs));
1609 const bool in_out_physical =
1610 (Config->get_input_auto_connect() & AutoConnectPhysical)
1611 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1614 const ChanCount in_offset = in_out_physical
1615 ? ChanCount::max(existing_inputs, existing_outputs)
1618 const ChanCount out_offset = in_out_physical
1619 ? ChanCount::max(existing_inputs, existing_outputs)
1622 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1623 vector<string> physinputs;
1624 vector<string> physoutputs;
1626 _engine.get_physical_outputs (*t, physoutputs);
1627 _engine.get_physical_inputs (*t, physinputs);
1629 if (!physinputs.empty() && connect_inputs) {
1630 uint32_t nphysical_in = physinputs.size();
1632 DEBUG_TRACE (DEBUG::Graph,
1633 string_compose("There are %1 physical inputs of type %2\n",
1636 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1639 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1640 DEBUG_TRACE (DEBUG::Graph,
1641 string_compose("Get index %1 + %2 % %3 = %4\n",
1642 in_offset.get(*t), i, nphysical_in,
1643 (in_offset.get(*t) + i) % nphysical_in));
1644 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1647 DEBUG_TRACE (DEBUG::Graph,
1648 string_compose("Connect route %1 IN to %2\n",
1649 route->name(), port));
1651 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1655 ChanCount one_added (*t, 1);
1656 existing_inputs += one_added;
1660 if (!physoutputs.empty()) {
1661 uint32_t nphysical_out = physoutputs.size();
1662 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1665 if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
1666 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1667 } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
1668 /* master bus is audio only */
1669 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1670 port = _master_out->input()->ports().port(*t,
1671 i % _master_out->input()->n_ports().get(*t))->name();
1675 DEBUG_TRACE (DEBUG::Graph,
1676 string_compose("Connect route %1 OUT to %2\n",
1677 route->name(), port));
1679 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
1683 ChanCount one_added (*t, 1);
1684 existing_outputs += one_added;
1690 /** Caller must not hold process lock
1691 * @param name_template string to use for the start of the name, or "" to use "Audio".
1693 list< boost::shared_ptr<AudioTrack> >
1694 Session::new_audio_track (
1695 int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template
1698 char track_name[32];
1699 uint32_t track_id = 0;
1701 RouteList new_routes;
1702 list<boost::shared_ptr<AudioTrack> > ret;
1703 uint32_t control_id;
1705 control_id = ntracks() + nbusses() + 1;
1707 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
1710 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1711 error << "cannot find name for new audio track" << endmsg;
1715 boost::shared_ptr<AudioTrack> track;
1718 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
1720 if (track->init ()) {
1724 track->use_new_diskstream();
1726 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1727 boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1730 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1732 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1733 error << string_compose (
1734 _("cannot configure %1 in/%2 out configuration for new audio track"),
1735 input_channels, output_channels)
1740 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1741 error << string_compose (
1742 _("cannot configure %1 in/%2 out configuration for new audio track"),
1743 input_channels, output_channels)
1750 route_group->add (track);
1753 track->non_realtime_input_change();
1755 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1756 track->set_remote_control_id (control_id);
1759 new_routes.push_back (track);
1760 ret.push_back (track);
1763 catch (failed_constructor &err) {
1764 error << _("Session: could not create new audio track.") << endmsg;
1768 catch (AudioEngine::PortRegistrationFailure& pfe) {
1770 error << pfe.what() << endmsg;
1778 if (!new_routes.empty()) {
1779 add_routes (new_routes, true, true);
1786 Session::set_remote_control_ids ()
1788 RemoteModel m = Config->get_remote_model();
1789 bool emit_signal = false;
1791 boost::shared_ptr<RouteList> r = routes.reader ();
1793 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1794 if (MixerOrdered == m) {
1795 int32_t order = (*i)->order_key(N_("signal"));
1796 (*i)->set_remote_control_id (order+1, false);
1798 } else if (EditorOrdered == m) {
1799 int32_t order = (*i)->order_key(N_("editor"));
1800 (*i)->set_remote_control_id (order+1, false);
1802 } else if (UserOrdered == m) {
1803 //do nothing ... only changes to remote id's are initiated by user
1808 Route::RemoteControlIDChange();
1812 /** Caller must not hold process lock.
1813 * @param name_template string to use for the start of the name, or "" to use "Bus".
1816 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
1819 uint32_t bus_id = 0;
1822 uint32_t control_id;
1824 control_id = ntracks() + nbusses() + 1;
1826 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
1829 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
1830 error << "cannot find name for new audio bus" << endmsg;
1835 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
1841 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1842 boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
1845 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1847 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1848 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1849 input_channels, output_channels)
1855 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1856 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1857 input_channels, output_channels)
1864 route_group->add (bus);
1866 bus->set_remote_control_id (control_id);
1869 bus->add_internal_return ();
1871 ret.push_back (bus);
1875 catch (failed_constructor &err) {
1876 error << _("Session: could not create new audio route.") << endmsg;
1880 catch (AudioEngine::PortRegistrationFailure& pfe) {
1881 error << pfe.what() << endmsg;
1891 add_routes (ret, false, true);
1899 Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
1903 uint32_t control_id;
1905 uint32_t number = 0;
1907 if (!tree.read (template_path.c_str())) {
1911 XMLNode* node = tree.root();
1913 control_id = ntracks() + nbusses() + 1;
1917 XMLNode node_copy (*node); // make a copy so we can change the name if we need to
1919 std::string node_name = IO::name_from_state (*node_copy.children().front());
1921 /* generate a new name by adding a number to the end of the template name */
1922 if (!find_route_name (node_name.c_str(), ++number, name, sizeof(name), true)) {
1923 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
1927 /* set IO children to use the new name */
1928 XMLNodeList const & children = node_copy.children ();
1929 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
1930 if ((*i)->name() == IO::state_node_name) {
1931 IO::set_name_in_state (**i, name);
1935 Track::zero_diskstream_id_in_xml (node_copy);
1938 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
1941 error << _("Session: cannot create track/bus from template description") << endmsg;
1945 if (boost::dynamic_pointer_cast<Track>(route)) {
1946 /* force input/output change signals so that the new diskstream
1947 picks up the configuration of the route. During session
1948 loading this normally happens in a different way.
1951 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1953 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
1954 change.after = route->input()->n_ports();
1955 route->input()->changed (change, this);
1956 change.after = route->output()->n_ports();
1957 route->output()->changed (change, this);
1960 route->set_remote_control_id (control_id);
1963 ret.push_back (route);
1966 catch (failed_constructor &err) {
1967 error << _("Session: could not create new route from template") << endmsg;
1971 catch (AudioEngine::PortRegistrationFailure& pfe) {
1972 error << pfe.what() << endmsg;
1981 add_routes (ret, true, true);
1988 Session::add_routes (RouteList& new_routes, bool auto_connect, bool save)
1990 ChanCount existing_inputs;
1991 ChanCount existing_outputs;
1993 count_existing_track_channels (existing_inputs, existing_outputs);
1996 RCUWriter<RouteList> writer (routes);
1997 boost::shared_ptr<RouteList> r = writer.get_copy ();
1998 r->insert (r->end(), new_routes.begin(), new_routes.end());
2000 /* if there is no control out and we're not in the middle of loading,
2001 resort the graph here. if there is a control out, we will resort
2002 toward the end of this method. if we are in the middle of loading,
2003 we will resort when done.
2006 if (!_monitor_out && IO::connecting_legal) {
2007 resort_routes_using (r);
2011 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2013 boost::weak_ptr<Route> wpr (*x);
2014 boost::shared_ptr<Route> r (*x);
2016 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2017 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2018 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2019 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2020 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2021 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2022 r->order_key_changed.connect_same_thread (*this, boost::bind (&Session::route_order_key_changed, this));
2024 if (r->is_master()) {
2028 if (r->is_monitor()) {
2032 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2034 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2035 track_playlist_changed (boost::weak_ptr<Track> (tr));
2036 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2038 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2040 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2041 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2046 auto_connect_route (r, existing_inputs, existing_outputs, true);
2050 if (_monitor_out && IO::connecting_legal) {
2052 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2053 if ((*x)->is_monitor()) {
2055 } else if ((*x)->is_master()) {
2058 (*x)->listen_via_monitor ();
2068 save_state (_current_snapshot_name);
2071 RouteAdded (new_routes); /* EMIT SIGNAL */
2072 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
2076 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2078 boost::shared_ptr<RouteList> r = routes.reader ();
2079 boost::shared_ptr<Send> s;
2081 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2082 if ((s = (*i)->internal_send_for (dest)) != 0) {
2083 s->amp()->gain_control()->set_value (0.0);
2089 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2091 boost::shared_ptr<RouteList> r = routes.reader ();
2092 boost::shared_ptr<Send> s;
2094 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2095 if ((s = (*i)->internal_send_for (dest)) != 0) {
2096 s->amp()->gain_control()->set_value (1.0);
2102 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2104 boost::shared_ptr<RouteList> r = routes.reader ();
2105 boost::shared_ptr<Send> s;
2107 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2108 if ((s = (*i)->internal_send_for (dest)) != 0) {
2109 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2114 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2116 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2118 boost::shared_ptr<RouteList> r = routes.reader ();
2119 boost::shared_ptr<RouteList> t (new RouteList);
2121 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2122 /* no MIDI sends because there are no MIDI busses yet */
2123 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2128 add_internal_sends (dest, p, t);
2132 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2134 if (dest->is_monitor() || dest->is_master()) {
2138 if (!dest->internal_return()) {
2139 dest->add_internal_return();
2142 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2144 if ((*i)->is_monitor() || (*i)->is_master() || (*i) == dest) {
2148 (*i)->listen_via (dest, p);
2155 Session::remove_route (boost::shared_ptr<Route> route)
2157 if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
2161 route->set_solo (false, this);
2164 RCUWriter<RouteList> writer (routes);
2165 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2169 /* deleting the master out seems like a dumb
2170 idea, but its more of a UI policy issue
2174 if (route == _master_out) {
2175 _master_out = boost::shared_ptr<Route> ();
2178 if (route == _monitor_out) {
2180 /* cancel control outs for all routes */
2182 for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2183 (*r)->drop_listen (_monitor_out);
2186 _monitor_out.reset ();
2189 /* writer goes out of scope, forces route list update */
2192 update_route_solo_state ();
2194 // We need to disconnect the route's inputs and outputs
2196 route->input()->disconnect (0);
2197 route->output()->disconnect (0);
2199 /* if the route had internal sends sending to it, remove them */
2200 if (route->internal_return()) {
2202 boost::shared_ptr<RouteList> r = routes.reader ();
2203 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2204 boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2206 (*i)->remove_processor (s);
2211 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2212 if (mt && mt->step_editing()) {
2213 if (_step_editors > 0) {
2218 update_latency_compensation ();
2221 /* Re-sort routes to remove the graph's current references to the one that is
2222 * going away, then flush old references out of the graph.
2226 route_graph->clear_other_chain ();
2228 /* get rid of it from the dead wood collection in the route list manager */
2230 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2234 /* try to cause everyone to drop their references */
2236 route->drop_references ();
2238 sync_order_keys (N_("session"));
2240 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2242 /* save the new state of the world */
2244 if (save_state (_current_snapshot_name)) {
2245 save_history (_current_snapshot_name);
2250 Session::route_mute_changed (void* /*src*/)
2256 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2258 boost::shared_ptr<Route> route = wpr.lock();
2260 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2264 if (route->listening_via_monitor ()) {
2266 if (Config->get_exclusive_solo()) {
2267 /* new listen: disable all other listen */
2268 boost::shared_ptr<RouteList> r = routes.reader ();
2269 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2270 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2273 (*i)->set_listen (false, this);
2279 } else if (_listen_cnt > 0) {
2284 update_route_solo_state ();
2287 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2289 boost::shared_ptr<Route> route = wpr.lock ();
2292 /* should not happen */
2293 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2297 bool send_changed = false;
2299 if (route->solo_isolated()) {
2300 if (_solo_isolated_cnt == 0) {
2301 send_changed = true;
2303 _solo_isolated_cnt++;
2304 } else if (_solo_isolated_cnt > 0) {
2305 _solo_isolated_cnt--;
2306 if (_solo_isolated_cnt == 0) {
2307 send_changed = true;
2312 IsolatedChanged (); /* EMIT SIGNAL */
2317 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2319 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2321 if (!self_solo_change) {
2322 // session doesn't care about changes to soloed-by-others
2326 if (solo_update_disabled) {
2328 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2332 boost::shared_ptr<Route> route = wpr.lock ();
2335 boost::shared_ptr<RouteList> r = routes.reader ();
2338 if (route->self_soloed()) {
2344 RouteGroup* rg = route->route_group ();
2345 bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2347 if (delta == 1 && Config->get_exclusive_solo()) {
2349 /* new solo: disable all other solos, but not the group if its solo-enabled */
2351 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2352 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2353 (leave_group_alone && ((*i)->route_group() == rg))) {
2356 (*i)->set_solo (false, this);
2360 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2362 solo_update_disabled = true;
2364 RouteList uninvolved;
2366 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2368 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2369 bool via_sends_only;
2370 bool in_signal_flow;
2372 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2373 (leave_group_alone && ((*i)->route_group() == rg))) {
2377 in_signal_flow = false;
2379 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2381 if ((*i)->feeds (route, &via_sends_only)) {
2382 if (!via_sends_only) {
2383 if (!route->soloed_by_others_upstream()) {
2384 (*i)->mod_solo_by_others_downstream (delta);
2387 in_signal_flow = true;
2389 DEBUG_TRACE (DEBUG::Solo, "\tno feed from\n");
2392 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2394 if (route->feeds (*i, &via_sends_only)) {
2395 /* propagate solo upstream only if routing other than
2396 sends is involved, but do consider the other route
2397 (*i) to be part of the signal flow even if only
2400 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2404 route->soloed_by_others_downstream(),
2405 route->soloed_by_others_upstream()));
2406 if (!via_sends_only) {
2407 if (!route->soloed_by_others_downstream()) {
2408 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2409 (*i)->mod_solo_by_others_upstream (delta);
2412 in_signal_flow = true;
2414 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2417 if (!in_signal_flow) {
2418 uninvolved.push_back (*i);
2422 solo_update_disabled = false;
2423 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2425 update_route_solo_state (r);
2427 /* now notify that the mute state of the routes not involved in the signal
2428 pathway of the just-solo-changed route may have altered.
2431 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2432 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1\n", (*i)->name()));
2433 (*i)->mute_changed (this);
2436 SoloChanged (); /* EMIT SIGNAL */
2441 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2443 /* now figure out if anything that matters is soloed (or is "listening")*/
2445 bool something_soloed = false;
2446 uint32_t listeners = 0;
2447 uint32_t isolated = 0;
2450 r = routes.reader();
2453 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2454 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2455 something_soloed = true;
2458 if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
2459 if (Config->get_solo_control_is_listen_control()) {
2462 (*i)->set_listen (false, this);
2466 if ((*i)->solo_isolated()) {
2471 if (something_soloed != _non_soloed_outs_muted) {
2472 _non_soloed_outs_muted = something_soloed;
2473 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2476 _listen_cnt = listeners;
2478 if (isolated != _solo_isolated_cnt) {
2479 _solo_isolated_cnt = isolated;
2480 IsolatedChanged (); /* EMIT SIGNAL */
2484 boost::shared_ptr<RouteList>
2485 Session::get_routes_with_internal_returns() const
2487 boost::shared_ptr<RouteList> r = routes.reader ();
2488 boost::shared_ptr<RouteList> rl (new RouteList);
2490 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2491 if ((*i)->internal_return ()) {
2499 Session::io_name_is_legal (const std::string& name)
2501 boost::shared_ptr<RouteList> r = routes.reader ();
2503 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2504 if ((*i)->name() == name) {
2508 if ((*i)->has_io_processor_named (name)) {
2517 Session::set_exclusive_input_active (boost::shared_ptr<Route> rt, bool /*others_on*/)
2520 vector<string> connections;
2522 PortSet& ps (rt->input()->ports());
2524 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2525 p->get_connections (connections);
2528 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2529 routes_using_input_from (*s, rl);
2532 /* scan all relevant routes to see if others are on or off */
2534 bool others_are_already_on = false;
2536 for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2538 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2540 if (mt->input_active()) {
2541 others_are_already_on = true;
2548 /* globally reverse other routes */
2550 for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2552 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2554 mt->set_input_active (!others_are_already_on);
2561 Session::routes_using_input_from (const string& str, RouteList& rl)
2563 boost::shared_ptr<RouteList> r = routes.reader ();
2565 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2566 if ((*i)->input()->connected_to (str)) {
2572 boost::shared_ptr<Route>
2573 Session::route_by_name (string name)
2575 boost::shared_ptr<RouteList> r = routes.reader ();
2577 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2578 if ((*i)->name() == name) {
2583 return boost::shared_ptr<Route> ((Route*) 0);
2586 boost::shared_ptr<Route>
2587 Session::route_by_id (PBD::ID id)
2589 boost::shared_ptr<RouteList> r = routes.reader ();
2591 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2592 if ((*i)->id() == id) {
2597 return boost::shared_ptr<Route> ((Route*) 0);
2600 boost::shared_ptr<Route>
2601 Session::route_by_remote_id (uint32_t id)
2603 boost::shared_ptr<RouteList> r = routes.reader ();
2605 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2606 if ((*i)->remote_control_id() == id) {
2611 return boost::shared_ptr<Route> ((Route*) 0);
2615 Session::playlist_region_added (boost::weak_ptr<Region> w)
2617 boost::shared_ptr<Region> r = w.lock ();
2622 /* These are the operations that are currently in progress... */
2623 list<GQuark> curr = _current_trans_quarks;
2626 /* ...and these are the operations during which we want to update
2627 the session range location markers.
2630 ops.push_back (Operations::capture);
2631 ops.push_back (Operations::paste);
2632 ops.push_back (Operations::duplicate_region);
2633 ops.push_back (Operations::insert_file);
2634 ops.push_back (Operations::insert_region);
2635 ops.push_back (Operations::drag_region_brush);
2636 ops.push_back (Operations::region_drag);
2637 ops.push_back (Operations::selection_grab);
2638 ops.push_back (Operations::region_fill);
2639 ops.push_back (Operations::fill_selection);
2640 ops.push_back (Operations::create_region);
2641 ops.push_back (Operations::region_copy);
2642 ops.push_back (Operations::fixed_time_region_copy);
2645 /* See if any of the current operations match the ones that we want */
2647 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2649 /* If so, update the session range markers */
2651 maybe_update_session_range (r->position (), r->last_frame ());
2655 /** Update the session range markers if a is before the current start or
2656 * b is after the current end.
2659 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2661 if (_state_of_the_state & Loading) {
2665 if (_session_range_location == 0) {
2667 add_session_range_location (a, b);
2671 if (a < _session_range_location->start()) {
2672 _session_range_location->set_start (a);
2675 if (b > _session_range_location->end()) {
2676 _session_range_location->set_end (b);
2682 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2684 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2685 maybe_update_session_range (i->to, i->to + i->length);
2690 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2692 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2693 maybe_update_session_range (i->from, i->to);
2697 /* Region management */
2699 boost::shared_ptr<Region>
2700 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2702 const RegionFactory::RegionMap& regions (RegionFactory::regions());
2703 RegionFactory::RegionMap::const_iterator i;
2704 boost::shared_ptr<Region> region;
2706 Glib::Mutex::Lock lm (region_lock);
2708 for (i = regions.begin(); i != regions.end(); ++i) {
2712 if (region->whole_file()) {
2714 if (child->source_equivalent (region)) {
2720 return boost::shared_ptr<Region> ();
2724 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2726 set<boost::shared_ptr<Region> > relevant_regions;
2728 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2729 RegionFactory::get_regions_using_source (*s, relevant_regions);
2732 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2733 set<boost::shared_ptr<Region> >::iterator tmp;
2738 playlists->destroy_region (*r);
2739 RegionFactory::map_remove (*r);
2741 (*r)->drop_sources ();
2742 (*r)->drop_references ();
2744 relevant_regions.erase (r);
2749 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2752 Glib::Mutex::Lock ls (source_lock);
2753 /* remove from the main source list */
2754 sources.erase ((*s)->id());
2757 (*s)->mark_for_remove ();
2758 (*s)->drop_references ();
2767 Session::remove_last_capture ()
2769 list<boost::shared_ptr<Source> > srcs;
2771 boost::shared_ptr<RouteList> rl = routes.reader ();
2772 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2773 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2778 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
2781 srcs.insert (srcs.end(), l.begin(), l.end());
2786 destroy_sources (srcs);
2788 save_state (_current_snapshot_name);
2793 /* Source Management */
2796 Session::add_source (boost::shared_ptr<Source> source)
2798 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
2799 pair<SourceMap::iterator,bool> result;
2801 entry.first = source->id();
2802 entry.second = source;
2805 Glib::Mutex::Lock lm (source_lock);
2806 result = sources.insert (entry);
2809 if (result.second) {
2811 /* yay, new source */
2815 boost::shared_ptr<AudioFileSource> afs;
2817 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2818 if (Config->get_auto_analyse_audio()) {
2819 Analyser::queue_source_for_analysis (source, false);
2823 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
2828 Session::remove_source (boost::weak_ptr<Source> src)
2830 if (_state_of_the_state & Deletion) {
2834 SourceMap::iterator i;
2835 boost::shared_ptr<Source> source = src.lock();
2842 Glib::Mutex::Lock lm (source_lock);
2844 if ((i = sources.find (source->id())) != sources.end()) {
2849 if (!_state_of_the_state & InCleanup) {
2851 /* save state so we don't end up with a session file
2852 referring to non-existent sources.
2855 save_state (_current_snapshot_name);
2859 boost::shared_ptr<Source>
2860 Session::source_by_id (const PBD::ID& id)
2862 Glib::Mutex::Lock lm (source_lock);
2863 SourceMap::iterator i;
2864 boost::shared_ptr<Source> source;
2866 if ((i = sources.find (id)) != sources.end()) {
2873 boost::shared_ptr<Source>
2874 Session::source_by_path_and_channel (const string& path, uint16_t chn)
2876 Glib::Mutex::Lock lm (source_lock);
2878 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2879 boost::shared_ptr<AudioFileSource> afs
2880 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2882 if (afs && afs->path() == path && chn == afs->channel()) {
2886 return boost::shared_ptr<Source>();
2890 Session::count_sources_by_origin (const string& path)
2893 Glib::Mutex::Lock lm (source_lock);
2895 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2896 boost::shared_ptr<FileSource> fs
2897 = boost::dynamic_pointer_cast<FileSource>(i->second);
2899 if (fs && fs->origin() == path) {
2909 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
2912 string old_basename = PBD::basename_nosuffix (oldname);
2913 string new_legalized = legalize_for_path (newname);
2915 /* note: we know (or assume) the old path is already valid */
2919 /* destructive file sources have a name of the form:
2921 /path/to/Tnnnn-NAME(%[LR])?.wav
2923 the task here is to replace NAME with the new name.
2928 string::size_type dash;
2930 dir = Glib::path_get_dirname (path);
2931 path = Glib::path_get_basename (path);
2933 /* '-' is not a legal character for the NAME part of the path */
2935 if ((dash = path.find_last_of ('-')) == string::npos) {
2939 prefix = path.substr (0, dash);
2943 path += new_legalized;
2944 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
2945 path = Glib::build_filename (dir, path);
2949 /* non-destructive file sources have a name of the form:
2951 /path/to/NAME-nnnnn(%[LR])?.ext
2953 the task here is to replace NAME with the new name.
2958 string::size_type dash;
2959 string::size_type postfix;
2961 dir = Glib::path_get_dirname (path);
2962 path = Glib::path_get_basename (path);
2964 /* '-' is not a legal character for the NAME part of the path */
2966 if ((dash = path.find_last_of ('-')) == string::npos) {
2970 suffix = path.substr (dash+1);
2972 // Suffix is now everything after the dash. Now we need to eliminate
2973 // the nnnnn part, which is done by either finding a '%' or a '.'
2975 postfix = suffix.find_last_of ("%");
2976 if (postfix == string::npos) {
2977 postfix = suffix.find_last_of ('.');
2980 if (postfix != string::npos) {
2981 suffix = suffix.substr (postfix);
2983 error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
2987 const uint32_t limit = 10000;
2988 char buf[PATH_MAX+1];
2990 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
2992 snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
2994 if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
2995 path = Glib::build_filename (dir, buf);
3003 fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3012 /** Return the full path (in some session directory) for a new within-session source.
3013 * \a name must be a session-unique name that does not contain slashes
3014 * (e.g. as returned by new_*_source_name)
3017 Session::new_source_path_from_name (DataType type, const string& name)
3019 assert(name.find("/") == string::npos);
3021 SessionDirectory sdir(get_best_session_directory_for_new_source());
3024 if (type == DataType::AUDIO) {
3025 p = sdir.sound_path();
3026 } else if (type == DataType::MIDI) {
3027 p = sdir.midi_path();
3029 error << "Unknown source type, unable to create file path" << endmsg;
3034 return p.to_string();
3038 Session::peak_path (string base) const
3040 sys::path peakfile_path(_session_dir->peak_path());
3041 peakfile_path /= base + peakfile_suffix;
3042 return peakfile_path.to_string();
3045 /** Return a unique name based on \a base for a new internal audio source */
3047 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3050 char buf[PATH_MAX+1];
3051 const uint32_t limit = 10000;
3053 string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3056 legalized = legalize_for_path (base);
3058 // Find a "version" of the base name that doesn't exist in any of the possible directories.
3059 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3061 vector<space_and_path>::iterator i;
3062 uint32_t existing = 0;
3064 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3069 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3070 cnt, legalized.c_str(), ext.c_str());
3071 } else if (nchan == 2) {
3073 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3074 cnt, legalized.c_str(), ext.c_str());
3076 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3077 cnt, legalized.c_str(), ext.c_str());
3079 } else if (nchan < 26) {
3080 snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3081 cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3083 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3084 cnt, legalized.c_str(), ext.c_str());
3090 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3091 } else if (nchan == 2) {
3093 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3095 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3097 } else if (nchan < 26) {
3098 snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3100 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3104 SessionDirectory sdir((*i).path);
3106 string spath = sdir.sound_path().to_string();
3108 /* note that we search *without* the extension so that
3109 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3110 in the event that this new name is required for
3111 a file format change.
3114 if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3120 if (existing == 0) {
3125 error << string_compose(
3126 _("There are already %1 recordings for %2, which I consider too many."),
3127 limit, base) << endmsg;
3129 throw failed_constructor();
3133 return Glib::path_get_basename (buf);
3136 /** Create a new within-session audio source */
3137 boost::shared_ptr<AudioFileSource>
3138 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3140 const string name = new_audio_source_name (n, n_chans, chan, destructive);
3141 const string path = new_source_path_from_name(DataType::AUDIO, name);
3143 return boost::dynamic_pointer_cast<AudioFileSource> (
3144 SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
3147 /** Return a unique name based on \a base for a new internal MIDI source */
3149 Session::new_midi_source_name (const string& base)
3152 char buf[PATH_MAX+1];
3153 const uint32_t limit = 10000;
3157 legalized = legalize_for_path (base);
3159 // Find a "version" of the file name that doesn't exist in any of the possible directories.
3160 for (cnt = 1; cnt <= limit; ++cnt) {
3162 vector<space_and_path>::iterator i;
3163 uint32_t existing = 0;
3165 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3167 SessionDirectory sdir((*i).path);
3169 sys::path p = sdir.midi_path();
3172 snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
3174 if (sys::exists (buf)) {
3179 if (existing == 0) {
3184 error << string_compose(
3185 _("There are already %1 recordings for %2, which I consider too many."),
3186 limit, base) << endmsg;
3188 throw failed_constructor();
3192 return Glib::path_get_basename(buf);
3196 /** Create a new within-session MIDI source */
3197 boost::shared_ptr<MidiSource>
3198 Session::create_midi_source_for_session (Track* track, string const & n)
3200 /* try to use the existing write source for the track, to keep numbering sane
3204 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3208 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3211 assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3212 return boost::dynamic_pointer_cast<MidiSource> (l.front());
3216 const string name = new_midi_source_name (n);
3217 const string path = new_source_path_from_name (DataType::MIDI, name);
3219 return boost::dynamic_pointer_cast<SMFSource> (
3220 SourceFactory::createWritable (
3221 DataType::MIDI, *this, path, string(), false, frame_rate()));
3226 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3228 if (playlist->hidden()) {
3232 playlists->add (playlist);
3235 playlist->release();
3242 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3244 if (_state_of_the_state & Deletion) {
3248 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3254 playlists->remove (playlist);
3260 Session::set_audition (boost::shared_ptr<Region> r)
3262 pending_audition_region = r;
3263 add_post_transport_work (PostTransportAudition);
3264 _butler->schedule_transport_work ();
3268 Session::audition_playlist ()
3270 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3271 ev->region.reset ();
3276 Session::non_realtime_set_audition ()
3278 if (!pending_audition_region) {
3279 auditioner->audition_current_playlist ();
3281 auditioner->audition_region (pending_audition_region);
3282 pending_audition_region.reset ();
3284 AuditionActive (true); /* EMIT SIGNAL */
3288 Session::audition_region (boost::shared_ptr<Region> r)
3290 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3296 Session::cancel_audition ()
3298 if (auditioner->auditioning()) {
3299 auditioner->cancel_audition ();
3300 AuditionActive (false); /* EMIT SIGNAL */
3305 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3307 if (a->is_monitor()) {
3310 if (b->is_monitor()) {
3313 return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3317 Session::is_auditioning () const
3319 /* can be called before we have an auditioner object */
3321 return auditioner->auditioning();
3328 Session::graph_reordered ()
3330 /* don't do this stuff if we are setting up connections
3331 from a set_state() call or creating new tracks. Ditto for deletion.
3334 if (_state_of_the_state & (InitialConnecting|Deletion)) {
3338 cerr << "Session begins graph reorder\n";
3340 /* every track/bus asked for this to be handled but it was deferred because
3341 we were connecting. do it now.
3344 request_input_change_handling ();
3346 cerr << "Session graph reorder 2\n";
3349 cerr << "Session graph reorder 3\n";
3351 /* force all diskstreams to update their capture offset values to
3352 reflect any changes in latencies within the graph.
3355 boost::shared_ptr<RouteList> rl = routes.reader ();
3356 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3357 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3359 tr->set_capture_offset ();
3363 cerr << "Session graph reorder 4\n";
3367 Session::available_capture_duration ()
3369 float sample_bytes_on_disk = 4.0; // keep gcc happy
3371 switch (config.get_native_file_data_format()) {
3373 sample_bytes_on_disk = 4.0;
3377 sample_bytes_on_disk = 3.0;
3381 sample_bytes_on_disk = 2.0;
3385 /* impossible, but keep some gcc versions happy */
3386 fatal << string_compose (_("programming error: %1"),
3387 X_("illegal native file data format"))
3392 double scale = 4096.0 / sample_bytes_on_disk;
3394 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3395 return max_framecnt;
3398 return (framecnt_t) floor (_total_free_4k_blocks * scale);
3402 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3405 RCUWriter<BundleList> writer (_bundles);
3406 boost::shared_ptr<BundleList> b = writer.get_copy ();
3407 b->push_back (bundle);
3410 BundleAdded (bundle); /* EMIT SIGNAL */
3416 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3418 bool removed = false;
3421 RCUWriter<BundleList> writer (_bundles);
3422 boost::shared_ptr<BundleList> b = writer.get_copy ();
3423 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3425 if (i != b->end()) {
3432 BundleRemoved (bundle); /* EMIT SIGNAL */
3438 boost::shared_ptr<Bundle>
3439 Session::bundle_by_name (string name) const
3441 boost::shared_ptr<BundleList> b = _bundles.reader ();
3443 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3444 if ((*i)->name() == name) {
3449 return boost::shared_ptr<Bundle> ();
3453 Session::tempo_map_changed (const PropertyChange&)
3457 playlists->update_after_tempo_map_change ();
3459 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3465 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3467 for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3468 (*i)->recompute_frames_from_bbt ();
3472 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3473 * the given count with the current block size.
3476 Session::ensure_buffers (ChanCount howmany)
3478 BufferManager::ensure_buffers (howmany);
3482 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3484 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3485 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3490 Session::next_insert_id ()
3492 /* this doesn't really loop forever. just think about it */
3495 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3496 if (!insert_bitset[n]) {
3497 insert_bitset[n] = true;
3503 /* none available, so resize and try again */
3505 insert_bitset.resize (insert_bitset.size() + 16, false);
3510 Session::next_send_id ()
3512 /* this doesn't really loop forever. just think about it */
3515 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3516 if (!send_bitset[n]) {
3517 send_bitset[n] = true;
3523 /* none available, so resize and try again */
3525 send_bitset.resize (send_bitset.size() + 16, false);
3530 Session::next_return_id ()
3532 /* this doesn't really loop forever. just think about it */
3535 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3536 if (!return_bitset[n]) {
3537 return_bitset[n] = true;
3543 /* none available, so resize and try again */
3545 return_bitset.resize (return_bitset.size() + 16, false);
3550 Session::mark_send_id (uint32_t id)
3552 if (id >= send_bitset.size()) {
3553 send_bitset.resize (id+16, false);
3555 if (send_bitset[id]) {
3556 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3558 send_bitset[id] = true;
3562 Session::mark_return_id (uint32_t id)
3564 if (id >= return_bitset.size()) {
3565 return_bitset.resize (id+16, false);
3567 if (return_bitset[id]) {
3568 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3570 return_bitset[id] = true;
3574 Session::mark_insert_id (uint32_t id)
3576 if (id >= insert_bitset.size()) {
3577 insert_bitset.resize (id+16, false);
3579 if (insert_bitset[id]) {
3580 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3582 insert_bitset[id] = true;
3586 Session::unmark_send_id (uint32_t id)
3588 if (id < send_bitset.size()) {
3589 send_bitset[id] = false;
3594 Session::unmark_return_id (uint32_t id)
3596 if (id < return_bitset.size()) {
3597 return_bitset[id] = false;
3602 Session::unmark_insert_id (uint32_t id)
3604 if (id < insert_bitset.size()) {
3605 insert_bitset[id] = false;
3610 /* Named Selection management */
3612 boost::shared_ptr<NamedSelection>
3613 Session::named_selection_by_name (string name)
3615 Glib::Mutex::Lock lm (named_selection_lock);
3616 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3617 if ((*i)->name == name) {
3621 return boost::shared_ptr<NamedSelection>();
3625 Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3628 Glib::Mutex::Lock lm (named_selection_lock);
3629 named_selections.insert (named_selections.begin(), named_selection);
3634 NamedSelectionAdded (); /* EMIT SIGNAL */
3638 Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3640 bool removed = false;
3643 Glib::Mutex::Lock lm (named_selection_lock);
3645 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3647 if (i != named_selections.end()) {
3648 named_selections.erase (i);
3655 NamedSelectionRemoved (); /* EMIT SIGNAL */
3660 Session::reset_native_file_format ()
3662 boost::shared_ptr<RouteList> rl = routes.reader ();
3663 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3664 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3666 /* don't save state as we do this, there's no point
3669 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3670 tr->reset_write_sources (false);
3671 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3677 Session::route_name_unique (string n) const
3679 boost::shared_ptr<RouteList> r = routes.reader ();
3681 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3682 if ((*i)->name() == n) {
3691 Session::route_name_internal (string n) const
3693 if (auditioner && auditioner->name() == n) {
3697 if (_click_io && _click_io->name() == n) {
3705 Session::freeze_all (InterThreadInfo& itt)
3707 boost::shared_ptr<RouteList> r = routes.reader ();
3709 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3711 boost::shared_ptr<Track> t;
3713 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3714 /* XXX this is wrong because itt.progress will keep returning to zero at the start
3724 boost::shared_ptr<Region>
3725 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3726 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3727 InterThreadInfo& itt, bool enable_processing)
3729 boost::shared_ptr<Region> result;
3730 boost::shared_ptr<Playlist> playlist;
3731 boost::shared_ptr<AudioFileSource> fsource;
3733 char buf[PATH_MAX+1];
3734 ChanCount diskstream_channels (track.n_channels());
3735 framepos_t position;
3736 framecnt_t this_chunk;
3739 SessionDirectory sdir(get_best_session_directory_for_new_source ());
3740 const string sound_dir = sdir.sound_path().to_string();
3741 framepos_t len = end - start;
3742 bool need_block_size_reset = false;
3744 ChanCount const max_proc = track.max_processor_streams ();
3747 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3748 end, start) << endmsg;
3752 const framecnt_t chunk_size = (256 * 1024)/4;
3754 // block all process callback handling
3756 block_processing ();
3758 /* call tree *MUST* hold route_lock */
3760 if ((playlist = track.playlist()) == 0) {
3764 /* external redirects will be a problem */
3766 if (track.has_external_redirects()) {
3770 ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3772 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3774 for (x = 0; x < 99999; ++x) {
3775 snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 "%s", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1, ext.c_str());
3776 if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3782 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3787 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3788 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
3791 catch (failed_constructor& err) {
3792 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3796 srcs.push_back (fsource);
3799 /* tell redirects that care that we are about to use a much larger blocksize */
3801 need_block_size_reset = true;
3802 track.set_block_size (chunk_size);
3804 /* XXX need to flush all redirects */
3809 /* create a set of reasonably-sized buffers */
3810 buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
3811 buffers.set_count (max_proc);
3813 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3814 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3816 afs->prepare_for_peakfile_writes ();
3819 while (to_do && !itt.cancel) {
3821 this_chunk = min (to_do, chunk_size);
3823 if (track.export_stuff (buffers, start, this_chunk, enable_processing)) {
3828 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3829 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3832 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
3838 start += this_chunk;
3839 to_do -= this_chunk;
3841 itt.progress = (float) (1.0 - ((double) to_do / len));
3850 xnow = localtime (&now);
3852 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3853 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3856 afs->update_header (position, *xnow, now);
3857 afs->flush_header ();
3861 /* construct a region to represent the bounced material */
3865 plist.add (Properties::start, 0);
3866 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
3867 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
3869 result = RegionFactory::create (srcs, plist);
3875 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3876 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3879 afs->mark_for_remove ();
3882 (*src)->drop_references ();
3886 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3887 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3890 afs->done_with_peakfile_writes ();
3895 if (need_block_size_reset) {
3896 track.set_block_size (get_block_size());
3899 unblock_processing ();
3905 Session::gain_automation_buffer() const
3907 return ProcessThread::gain_automation_buffer ();
3911 Session::pan_automation_buffer() const
3913 return ProcessThread::pan_automation_buffer ();
3917 Session::get_silent_buffers (ChanCount count)
3919 return ProcessThread::get_silent_buffers (count);
3923 Session::get_scratch_buffers (ChanCount count)
3925 return ProcessThread::get_scratch_buffers (count);
3929 Session::get_mix_buffers (ChanCount count)
3931 return ProcessThread::get_mix_buffers (count);
3935 Session::ntracks () const
3938 boost::shared_ptr<RouteList> r = routes.reader ();
3940 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3941 if (boost::dynamic_pointer_cast<Track> (*i)) {
3950 Session::nbusses () const
3953 boost::shared_ptr<RouteList> r = routes.reader ();
3955 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3956 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
3965 Session::add_automation_list(AutomationList *al)
3967 automation_lists[al->id()] = al;
3971 Session::sync_order_keys (std::string const & base)
3973 if (deletion_in_progress()) {
3977 if (!Config->get_sync_all_route_ordering()) {
3978 /* leave order keys as they are */
3982 boost::shared_ptr<RouteList> r = routes.reader ();
3984 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3985 (*i)->sync_order_keys (base);
3988 Route::SyncOrderKeys (base); // EMIT SIGNAL
3990 /* this might not do anything */
3992 set_remote_control_ids ();
3995 /** @return true if there is at least one record-enabled track, otherwise false */
3997 Session::have_rec_enabled_track () const
3999 return g_atomic_int_get (&_have_rec_enabled_track) == 1;
4002 /** Update the state of our rec-enabled tracks flag */
4004 Session::update_have_rec_enabled_track ()
4006 boost::shared_ptr<RouteList> rl = routes.reader ();
4007 RouteList::iterator i = rl->begin();
4008 while (i != rl->end ()) {
4010 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4011 if (tr && tr->record_enabled ()) {
4018 int const old = g_atomic_int_get (&_have_rec_enabled_track);
4020 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4022 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4023 RecordStateChanged (); /* EMIT SIGNAL */
4028 Session::listen_position_changed ()
4030 boost::shared_ptr<RouteList> r = routes.reader ();
4032 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4033 (*i)->listen_position_changed ();
4038 Session::solo_control_mode_changed ()
4040 /* cancel all solo or all listen when solo control mode changes */
4043 set_solo (get_routes(), false);
4044 } else if (listening()) {
4045 set_listen (get_routes(), false);
4049 /** Called when a property of one of our route groups changes */
4051 Session::route_group_property_changed (RouteGroup* rg)
4053 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4056 /** Called when a route is added to one of our route groups */
4058 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4060 RouteAddedToRouteGroup (rg, r);
4063 /** Called when a route is removed from one of our route groups */
4065 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4067 RouteRemovedFromRouteGroup (rg, r);
4071 Session::get_available_sync_options () const
4073 vector<SyncSource> ret;
4075 ret.push_back (JACK);
4076 ret.push_back (MTC);
4077 ret.push_back (MIDIClock);
4082 boost::shared_ptr<RouteList>
4083 Session::get_routes_with_regions_at (framepos_t const p) const
4085 boost::shared_ptr<RouteList> r = routes.reader ();
4086 boost::shared_ptr<RouteList> rl (new RouteList);
4088 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4089 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4094 boost::shared_ptr<Playlist> pl = tr->playlist ();
4099 if (pl->has_region_at (p)) {
4108 Session::goto_end ()
4110 if (_session_range_location) {
4111 request_locate (_session_range_location->end(), false);
4113 request_locate (0, false);
4118 Session::goto_start ()
4120 if (_session_range_location) {
4121 request_locate (_session_range_location->start(), false);
4123 request_locate (0, false);
4128 Session::current_start_frame () const
4130 return _session_range_location ? _session_range_location->start() : 0;
4134 Session::current_end_frame () const
4136 return _session_range_location ? _session_range_location->end() : 0;
4140 Session::add_session_range_location (framepos_t start, framepos_t end)
4142 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4143 _locations->add (_session_range_location);
4146 /** Called when one of our routes' order keys has changed */
4148 Session::route_order_key_changed ()
4150 RouteOrderKeyChanged (); /* EMIT SIGNAL */
4154 Session::step_edit_status_change (bool yn)
4160 send = (_step_editors == 0);
4165 send = (_step_editors == 1);
4168 if (_step_editors > 0) {
4174 StepEditStatusChange (val);
4180 Session::start_time_changed (framepos_t old)
4182 /* Update the auto loop range to match the session range
4183 (unless the auto loop range has been changed by the user)
4186 Location* s = _locations->session_range_location ();
4191 Location* l = _locations->auto_loop_location ();
4193 if (l->start() == old) {
4194 l->set_start (s->start(), true);
4199 Session::end_time_changed (framepos_t old)
4201 /* Update the auto loop range to match the session range
4202 (unless the auto loop range has been changed by the user)
4205 Location* s = _locations->session_range_location ();
4210 Location* l = _locations->auto_loop_location ();
4212 if (l && l->end() == old) {
4213 l->set_end (s->end(), true);
4218 Session::source_search_path (DataType type) const
4222 if (session_dirs.size() == 1) {
4224 case DataType::AUDIO:
4225 search_path = _session_dir->sound_path().to_string();
4227 case DataType::MIDI:
4228 search_path = _session_dir->midi_path().to_string();
4232 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4233 SessionDirectory sdir (i->path);
4234 if (!search_path.empty()) {
4238 case DataType::AUDIO:
4239 search_path += sdir.sound_path().to_string();
4241 case DataType::MIDI:
4242 search_path += sdir.midi_path().to_string();
4248 /* now add user-specified locations
4251 vector<string> dirs;
4254 case DataType::AUDIO:
4255 split (config.get_audio_search_path (), dirs, ':');
4257 case DataType::MIDI:
4258 split (config.get_midi_search_path (), dirs, ':');
4262 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4272 Session::ensure_search_path_includes (const string& path, DataType type)
4275 vector<string> dirs;
4282 case DataType::AUDIO:
4283 search_path = config.get_audio_search_path ();
4285 case DataType::MIDI:
4286 search_path = config.get_midi_search_path ();
4290 split (search_path, dirs, ':');
4292 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4298 if (!search_path.empty()) {
4302 search_path += path;
4305 case DataType::AUDIO:
4306 config.set_audio_search_path (search_path);
4308 case DataType::MIDI:
4309 config.set_midi_search_path (search_path);
4314 boost::shared_ptr<Speakers>
4315 Session::get_speakers()
4321 Session::unknown_processors () const
4325 boost::shared_ptr<RouteList> r = routes.reader ();
4326 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4327 list<string> t = (*i)->unknown_processors ();
4328 copy (t.begin(), t.end(), back_inserter (p));
4338 Session::update_latency (bool playback)
4340 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4342 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4346 boost::shared_ptr<RouteList> r = routes.reader ();
4347 framecnt_t max_latency = 0;
4350 /* reverse the list so that we work backwards from the last route to run to the first */
4351 RouteList* rl = routes.reader().get();
4352 r.reset (new RouteList (*rl));
4353 reverse (r->begin(), r->end());
4356 /* compute actual latency values for the given direction and store them all in per-port
4357 structures. this will also publish the same values (to JACK) so that computation of latency
4358 for routes can consistently use public latency values.
4361 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4362 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4365 /* because we latency compensate playback, our published playback latencies should
4366 be the same for all output ports - all material played back by ardour has
4367 the same latency, whether its caused by plugins or by latency compensation. since
4368 these may differ from the values computed above, reset all playback port latencies
4372 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4374 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4375 (*i)->set_public_port_latencies (max_latency, playback);
4380 post_playback_latency ();
4384 post_capture_latency ();
4387 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4391 Session::post_playback_latency ()
4393 set_worst_playback_latency ();
4395 boost::shared_ptr<RouteList> r = routes.reader ();
4397 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4398 if (!(*i)->is_hidden() && ((*i)->active())) {
4399 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4403 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4404 (*i)->set_latency_compensation (_worst_track_latency);
4409 Session::post_capture_latency ()
4411 set_worst_capture_latency ();
4413 /* reflect any changes in capture latencies into capture offsets
4416 boost::shared_ptr<RouteList> rl = routes.reader();
4417 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4418 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4420 tr->set_capture_offset ();
4426 Session::initialize_latencies ()
4429 Glib::Mutex::Lock lm (_engine.process_lock());
4430 update_latency (false);
4431 update_latency (true);
4434 set_worst_io_latencies ();
4438 Session::set_worst_io_latencies ()
4440 set_worst_playback_latency ();
4441 set_worst_capture_latency ();
4445 Session::set_worst_playback_latency ()
4447 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4451 _worst_output_latency = 0;
4453 if (!_engine.connected()) {
4457 boost::shared_ptr<RouteList> r = routes.reader ();
4459 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4460 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4463 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4467 Session::set_worst_capture_latency ()
4469 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4473 _worst_input_latency = 0;
4475 if (!_engine.connected()) {
4479 boost::shared_ptr<RouteList> r = routes.reader ();
4481 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4482 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4485 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4489 Session::update_latency_compensation (bool force_whole_graph)
4491 bool some_track_latency_changed = false;
4493 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4497 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4499 _worst_track_latency = 0;
4501 boost::shared_ptr<RouteList> r = routes.reader ();
4503 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4504 if (!(*i)->is_hidden() && ((*i)->active())) {
4506 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4507 some_track_latency_changed = true;
4509 _worst_track_latency = max (tl, _worst_track_latency);
4513 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4514 (some_track_latency_changed ? "yes" : "no")));
4516 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4518 if (some_track_latency_changed || force_whole_graph) {
4519 _engine.update_latencies ();
4523 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4524 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4528 tr->set_capture_offset ();