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"
48 #include "pbd/unwind.h"
50 #include "ardour/amp.h"
51 #include "ardour/analyser.h"
52 #include "ardour/audio_buffer.h"
53 #include "ardour/audio_diskstream.h"
54 #include "ardour/audio_port.h"
55 #include "ardour/audio_track.h"
56 #include "ardour/audioengine.h"
57 #include "ardour/audiofilesource.h"
58 #include "ardour/auditioner.h"
59 #include "ardour/buffer_manager.h"
60 #include "ardour/buffer_set.h"
61 #include "ardour/bundle.h"
62 #include "ardour/butler.h"
63 #include "ardour/click.h"
64 #include "ardour/control_protocol_manager.h"
65 #include "ardour/data_type.h"
66 #include "ardour/debug.h"
67 #include "ardour/filename_extensions.h"
68 #include "ardour/graph.h"
69 #include "ardour/midi_track.h"
70 #include "ardour/midi_ui.h"
71 #include "ardour/operations.h"
72 #include "ardour/playlist.h"
73 #include "ardour/plugin.h"
74 #include "ardour/plugin_insert.h"
75 #include "ardour/process_thread.h"
76 #include "ardour/rc_configuration.h"
77 #include "ardour/recent_sessions.h"
78 #include "ardour/region.h"
79 #include "ardour/region_factory.h"
80 #include "ardour/route_graph.h"
81 #include "ardour/route_group.h"
82 #include "ardour/send.h"
83 #include "ardour/session.h"
84 #include "ardour/session_directory.h"
85 #include "ardour/session_playlists.h"
86 #include "ardour/smf_source.h"
87 #include "ardour/source_factory.h"
88 #include "ardour/utils.h"
90 #include "midi++/port.h"
91 #include "midi++/jack_midi_port.h"
92 #include "midi++/mmc.h"
93 #include "midi++/manager.h"
104 using namespace ARDOUR;
107 bool Session::_disable_all_loaded_plugins = false;
109 PBD::Signal1<void,std::string> Session::Dialog;
110 PBD::Signal0<int> Session::AskAboutPendingState;
111 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
112 PBD::Signal0<void> Session::SendFeedback;
113 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
115 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
116 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
117 PBD::Signal2<void,std::string, std::string> Session::Exported;
118 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
119 PBD::Signal0<void> Session::Quit;
120 PBD::Signal0<void> Session::FeedbackDetected;
121 PBD::Signal0<void> Session::SuccessfulGraphSort;
123 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
124 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
126 /** @param snapshot_name Snapshot name, without .ardour suffix */
127 Session::Session (AudioEngine &eng,
128 const string& fullpath,
129 const string& snapshot_name,
130 BusProfile* bus_profile,
133 , _target_transport_speed (0.0)
134 , _requested_return_frame (-1)
135 , _session_dir (new SessionDirectory(fullpath))
137 , _state_of_the_state (Clean)
138 , _butler (new Butler (*this))
139 , _post_transport_work (0)
140 , _send_timecode_update (false)
141 , _all_route_group (new RouteGroup (*this, "all"))
142 , routes (new RouteList)
143 , _total_free_4k_blocks (0)
144 , _total_free_4k_blocks_uncertain (false)
145 , _bundles (new BundleList)
146 , _bundle_xml_node (0)
148 , _click_io ((IO*) 0)
150 , click_emphasis_data (0)
152 , _have_rec_enabled_track (false)
153 , _suspend_timecode_transmission (0)
155 _locations = new Locations (*this);
157 if (how_many_dsp_threads () > 1) {
158 /* For now, only create the graph if we are using >1 DSP threads, as
159 it is a bit slower than the old code with 1 thread.
161 _process_graph.reset (new Graph (*this));
164 playlists.reset (new SessionPlaylists);
166 _all_route_group->set_active (true, this);
168 interpolation.add_channel_to (0, 0);
170 if (!eng.connected()) {
171 throw failed_constructor();
174 n_physical_outputs = _engine.n_physical_outputs ();
175 n_physical_inputs = _engine.n_physical_inputs ();
177 first_stage_init (fullpath, snapshot_name);
179 _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
182 if (create (mix_template, bus_profile)) {
184 throw failed_constructor ();
188 if (second_stage_init ()) {
190 throw failed_constructor ();
193 store_recent_sessions(_name, _path);
195 bool was_dirty = dirty();
197 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
199 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
200 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
203 DirtyChanged (); /* EMIT SIGNAL */
206 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
207 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 /* deregister all ports - there will be no process or any other
236 * callbacks from the engine any more.
239 Port::PortDrop (); /* EMIT SIGNAL */
241 /* clear history so that no references to objects are held any more */
245 /* clear state tree so that no references to objects are held any more */
249 /* reset dynamic state version back to default */
251 Stateful::loading_state_version = 0;
253 _butler->drop_references ();
257 delete midi_control_ui;
258 delete _all_route_group;
260 if (click_data != default_click) {
261 delete [] click_data;
264 if (click_emphasis_data != default_click_emphasis) {
265 delete [] click_emphasis_data;
270 /* clear out any pending dead wood from RCU managed objects */
275 AudioDiskstream::free_working_buffers();
277 /* tell everyone who is still standing that we're about to die */
280 /* tell everyone to drop references and delete objects as we go */
282 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
283 RegionFactory::delete_all_regions ();
285 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
287 /* reset these three references to special routes before we do the usual route delete thing */
290 _master_out.reset ();
291 _monitor_out.reset ();
294 RCUWriter<RouteList> writer (routes);
295 boost::shared_ptr<RouteList> r = writer.get_copy ();
297 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
298 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
299 (*i)->drop_references ();
303 /* writer goes out of scope and updates master */
307 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
308 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
309 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
310 i->second->drop_references ();
315 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
316 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
321 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
326 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
328 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
329 boost_debug_list_ptrs ();
334 Session::when_engine_running ()
336 string first_physical_output;
338 BootMessage (_("Set block size and sample rate"));
340 set_block_size (_engine.frames_per_cycle());
341 set_frame_rate (_engine.frame_rate());
343 BootMessage (_("Using configuration"));
345 boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
346 boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
348 Config->map_parameters (ff);
349 config.map_parameters (ft);
351 /* every time we reconnect, recompute worst case output latencies */
353 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
355 if (synced_to_jack()) {
356 _engine.transport_stop ();
359 if (config.get_jack_time_master()) {
360 _engine.transport_locate (_transport_frame);
368 _click_io.reset (new ClickIO (*this, "click"));
369 _click_gain.reset (new Amp (*this));
370 _click_gain->activate ();
372 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
374 /* existing state for Click */
377 if (Stateful::loading_state_version < 3000) {
378 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
380 const XMLNodeList& children (child->children());
381 XMLNodeList::const_iterator i = children.begin();
382 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
384 if (i != children.end()) {
385 c = _click_gain->set_state (**i, Stateful::loading_state_version);
391 _clicking = Config->get_clicking ();
395 error << _("could not setup Click I/O") << endmsg;
402 /* default state for Click: dual-mono to first 2 physical outputs */
405 _engine.get_physical_outputs (DataType::AUDIO, outs);
407 for (uint32_t physport = 0; physport < 2; ++physport) {
408 if (outs.size() > physport) {
409 if (_click_io->add_port (outs[physport], this)) {
410 // relax, even though its an error
415 if (_click_io->n_ports () > ChanCount::ZERO) {
416 _clicking = Config->get_clicking ();
421 catch (failed_constructor& err) {
422 error << _("cannot setup Click I/O") << endmsg;
425 BootMessage (_("Compute I/O Latencies"));
428 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
431 BootMessage (_("Set up standard connections"));
433 vector<string> inputs[DataType::num_types];
434 vector<string> outputs[DataType::num_types];
435 for (uint32_t i = 0; i < DataType::num_types; ++i) {
436 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
437 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
440 /* Create a set of Bundle objects that map
441 to the physical I/O currently available. We create both
442 mono and stereo bundles, so that the common cases of mono
443 and stereo tracks get bundles to put in their mixer strip
444 in / out menus. There may be a nicer way of achieving that;
445 it doesn't really scale that well to higher channel counts
448 /* mono output bundles */
450 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
452 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
454 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
455 c->add_channel (_("mono"), DataType::AUDIO);
456 c->set_port (0, outputs[DataType::AUDIO][np]);
461 /* stereo output bundles */
463 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
464 if (np + 1 < outputs[DataType::AUDIO].size()) {
466 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
467 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
468 c->add_channel (_("L"), DataType::AUDIO);
469 c->set_port (0, outputs[DataType::AUDIO][np]);
470 c->add_channel (_("R"), DataType::AUDIO);
471 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
477 /* mono input bundles */
479 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
481 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
483 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
484 c->add_channel (_("mono"), DataType::AUDIO);
485 c->set_port (0, inputs[DataType::AUDIO][np]);
490 /* stereo input bundles */
492 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
493 if (np + 1 < inputs[DataType::AUDIO].size()) {
495 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
497 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
498 c->add_channel (_("L"), DataType::AUDIO);
499 c->set_port (0, inputs[DataType::AUDIO][np]);
500 c->add_channel (_("R"), DataType::AUDIO);
501 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
507 /* MIDI input bundles */
509 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
510 string n = inputs[DataType::MIDI][np];
511 boost::erase_first (n, X_("alsa_pcm:"));
513 boost::shared_ptr<Bundle> c (new Bundle (n, false));
514 c->add_channel ("", DataType::MIDI);
515 c->set_port (0, inputs[DataType::MIDI][np]);
519 /* MIDI output bundles */
521 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
522 string n = outputs[DataType::MIDI][np];
523 boost::erase_first (n, X_("alsa_pcm:"));
525 boost::shared_ptr<Bundle> c (new Bundle (n, true));
526 c->add_channel ("", DataType::MIDI);
527 c->set_port (0, outputs[DataType::MIDI][np]);
531 BootMessage (_("Setup signal flow and plugins"));
533 /* Reset all panners */
535 Delivery::reset_panners ();
537 /* this will cause the CPM to instantiate any protocols that are in use
538 * (or mandatory), which will pass it this Session, and then call
539 * set_state() on each instantiated protocol to match stored state.
542 ControlProtocolManager::instance().set_session (this);
544 /* This must be done after the ControlProtocolManager set_session above,
545 as it will set states for ports which the ControlProtocolManager creates.
548 MIDI::Manager::instance()->set_port_states (Config->midi_port_states ());
550 /* And this must be done after the MIDI::Manager::set_port_states as
551 * it will try to make connections whose details are loaded by set_port_states.
556 /* Let control protocols know that we are now all connected, so they
557 * could start talking to surfaces if they want to.
560 ControlProtocolManager::instance().midi_connectivity_established ();
562 if (_is_new && !no_auto_connect()) {
563 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
564 auto_connect_master_bus ();
567 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
569 /* update latencies */
571 initialize_latencies ();
573 /* hook us up to the engine */
575 BootMessage (_("Connect to engine"));
576 _engine.set_session (this);
580 Session::auto_connect_master_bus ()
582 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
586 /* if requested auto-connect the outputs to the first N physical ports.
589 uint32_t limit = _master_out->n_outputs().n_total();
590 vector<string> outputs[DataType::num_types];
592 for (uint32_t i = 0; i < DataType::num_types; ++i) {
593 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
596 for (uint32_t n = 0; n < limit; ++n) {
597 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
599 if (outputs[p->type()].size() > n) {
600 connect_to = outputs[p->type()][n];
603 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
604 if (_master_out->output()->connect (p, connect_to, this)) {
605 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
614 Session::remove_monitor_section ()
620 /* force reversion to Solo-In-Place */
621 Config->set_solo_control_is_listen_control (false);
624 /* Hold process lock while doing this so that we don't hear bits and
625 * pieces of audio as we work on each route.
628 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
630 /* Connect tracks to monitor section. Note that in an
631 existing session, the internal sends will already exist, but we want the
632 routes to notice that they connect to the control out specifically.
636 boost::shared_ptr<RouteList> r = routes.reader ();
637 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
639 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
641 if ((*x)->is_monitor()) {
643 } else if ((*x)->is_master()) {
646 (*x)->remove_aux_or_listen (_monitor_out);
651 remove_route (_monitor_out);
652 auto_connect_master_bus ();
656 Session::add_monitor_section ()
660 if (_monitor_out || !_master_out) {
664 boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
670 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
671 // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
674 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
675 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
676 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
680 add_routes (rl, false, false, false);
682 assert (_monitor_out);
684 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
685 are undefined, at best.
688 uint32_t limit = _monitor_out->n_inputs().n_audio();
692 /* connect the inputs to the master bus outputs. this
693 * represents a separate data feed from the internal sends from
694 * each route. as of jan 2011, it allows the monitor section to
695 * conditionally ignore either the internal sends or the normal
696 * input feed, but we should really find a better way to do
700 _master_out->output()->disconnect (this);
702 for (uint32_t n = 0; n < limit; ++n) {
703 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
704 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
707 string connect_to = o->name();
708 if (_monitor_out->input()->connect (p, connect_to, this)) {
709 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
717 /* if monitor section is not connected, connect it to physical outs
720 if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
722 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
724 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
727 _monitor_out->output()->connect_ports_to_bundle (b, this);
729 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
730 Config->get_monitor_bus_preferred_bundle())
736 /* Monitor bus is audio only */
738 uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
739 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
740 vector<string> outputs[DataType::num_types];
742 for (uint32_t i = 0; i < DataType::num_types; ++i) {
743 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
749 for (uint32_t n = 0; n < limit; ++n) {
751 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
753 if (outputs[DataType::AUDIO].size() > (n % mod)) {
754 connect_to = outputs[DataType::AUDIO][n % mod];
757 if (!connect_to.empty()) {
758 if (_monitor_out->output()->connect (p, connect_to, this)) {
759 error << string_compose (
760 _("cannot connect control output %1 to %2"),
771 /* Hold process lock while doing this so that we don't hear bits and
772 * pieces of audio as we work on each route.
775 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
777 /* Connect tracks to monitor section. Note that in an
778 existing session, the internal sends will already exist, but we want the
779 routes to notice that they connect to the control out specifically.
783 boost::shared_ptr<RouteList> rls = routes.reader ();
785 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
787 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
789 if ((*x)->is_monitor()) {
791 } else if ((*x)->is_master()) {
794 (*x)->enable_monitor_send ();
800 Session::hookup_io ()
802 /* stop graph reordering notifications from
803 causing resorts, etc.
806 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
810 /* we delay creating the auditioner till now because
811 it makes its own connections to ports.
815 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
817 throw failed_constructor ();
819 a->use_new_diskstream ();
823 catch (failed_constructor& err) {
824 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
828 /* load bundles, which we may have postponed earlier on */
829 if (_bundle_xml_node) {
830 load_bundles (*_bundle_xml_node);
831 delete _bundle_xml_node;
834 /* Tell all IO objects to connect themselves together */
836 IO::enable_connecting ();
837 MIDI::JackMIDIPort::MakeConnections ();
839 /* Anyone who cares about input state, wake up and do something */
841 IOConnectionsComplete (); /* EMIT SIGNAL */
843 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
845 /* now handle the whole enchilada as if it was one
851 /* update the full solo state, which can't be
852 correctly determined on a per-route basis, but
853 needs the global overview that only the session
857 update_route_solo_state ();
861 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
863 boost::shared_ptr<Track> track = wp.lock ();
868 boost::shared_ptr<Playlist> playlist;
870 if ((playlist = track->playlist()) != 0) {
871 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
872 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
873 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
878 Session::record_enabling_legal () const
880 /* this used to be in here, but survey says.... we don't need to restrict it */
881 // if (record_status() == Recording) {
885 if (Config->get_all_safe()) {
892 Session::set_track_monitor_input_status (bool yn)
894 boost::shared_ptr<RouteList> rl = routes.reader ();
895 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
896 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
897 if (tr && tr->record_enabled ()) {
898 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
899 tr->request_jack_monitors_input (yn);
905 Session::auto_punch_start_changed (Location* location)
907 replace_event (SessionEvent::PunchIn, location->start());
909 if (get_record_enabled() && config.get_punch_in()) {
910 /* capture start has been changed, so save new pending state */
911 save_state ("", true);
916 Session::auto_punch_end_changed (Location* location)
918 framepos_t when_to_stop = location->end();
919 // when_to_stop += _worst_output_latency + _worst_input_latency;
920 replace_event (SessionEvent::PunchOut, when_to_stop);
924 Session::auto_punch_changed (Location* location)
926 framepos_t when_to_stop = location->end();
928 replace_event (SessionEvent::PunchIn, location->start());
929 //when_to_stop += _worst_output_latency + _worst_input_latency;
930 replace_event (SessionEvent::PunchOut, when_to_stop);
933 /** @param loc A loop location.
934 * @param pos Filled in with the start time of the required fade-out (in session frames).
935 * @param length Filled in with the length of the required fade-out.
938 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
940 pos = max (loc->start(), loc->end() - 64);
941 length = loc->end() - pos;
945 Session::auto_loop_changed (Location* location)
947 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
950 auto_loop_declick_range (location, dcp, dcl);
951 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
953 if (transport_rolling() && play_loop) {
956 // if (_transport_frame > location->end()) {
958 if (_transport_frame < location->start() || _transport_frame > location->end()) {
959 // relocate to beginning of loop
960 clear_events (SessionEvent::LocateRoll);
962 request_locate (location->start(), true);
965 else if (Config->get_seamless_loop() && !loop_changing) {
967 // schedule a locate-roll to refill the diskstreams at the
969 loop_changing = true;
971 if (location->end() > last_loopend) {
972 clear_events (SessionEvent::LocateRoll);
973 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
980 last_loopend = location->end();
984 Session::set_auto_punch_location (Location* location)
988 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
989 punch_connections.drop_connections();
990 existing->set_auto_punch (false, this);
991 remove_event (existing->start(), SessionEvent::PunchIn);
992 clear_events (SessionEvent::PunchOut);
993 auto_punch_location_changed (0);
1002 if (location->end() <= location->start()) {
1003 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1007 punch_connections.drop_connections ();
1009 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
1010 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
1011 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
1013 location->set_auto_punch (true, this);
1015 auto_punch_changed (location);
1017 auto_punch_location_changed (location);
1021 Session::set_auto_loop_location (Location* location)
1025 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1026 loop_connections.drop_connections ();
1027 existing->set_auto_loop (false, this);
1028 remove_event (existing->end(), SessionEvent::AutoLoop);
1031 auto_loop_declick_range (existing, dcp, dcl);
1032 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1033 auto_loop_location_changed (0);
1038 if (location == 0) {
1042 if (location->end() <= location->start()) {
1043 error << _("Session: you can't use a mark for auto loop") << endmsg;
1047 last_loopend = location->end();
1049 loop_connections.drop_connections ();
1051 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1052 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1053 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1055 location->set_auto_loop (true, this);
1057 /* take care of our stuff first */
1059 auto_loop_changed (location);
1061 /* now tell everyone else */
1063 auto_loop_location_changed (location);
1067 Session::locations_added (Location *)
1073 Session::locations_changed ()
1075 _locations->apply (*this, &Session::handle_locations_changed);
1079 Session::handle_locations_changed (Locations::LocationList& locations)
1081 Locations::LocationList::iterator i;
1083 bool set_loop = false;
1084 bool set_punch = false;
1086 for (i = locations.begin(); i != locations.end(); ++i) {
1090 if (location->is_auto_punch()) {
1091 set_auto_punch_location (location);
1094 if (location->is_auto_loop()) {
1095 set_auto_loop_location (location);
1099 if (location->is_session_range()) {
1100 _session_range_location = location;
1105 set_auto_loop_location (0);
1108 set_auto_punch_location (0);
1115 Session::enable_record ()
1117 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1118 /* no recording at anything except normal speed */
1123 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1125 if (rs == Recording) {
1129 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1131 _last_record_location = _transport_frame;
1132 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1134 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1135 set_track_monitor_input_status (true);
1138 RecordStateChanged ();
1145 Session::disable_record (bool rt_context, bool force)
1149 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1151 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1152 g_atomic_int_set (&_record_status, Disabled);
1153 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1155 if (rs == Recording) {
1156 g_atomic_int_set (&_record_status, Enabled);
1160 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1161 set_track_monitor_input_status (false);
1164 RecordStateChanged (); /* emit signal */
1167 remove_pending_capture_state ();
1173 Session::step_back_from_record ()
1175 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1177 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1178 set_track_monitor_input_status (false);
1181 RecordStateChanged (); /* emit signal */
1186 Session::maybe_enable_record ()
1188 if (_step_editors > 0) {
1192 g_atomic_int_set (&_record_status, Enabled);
1194 /* This function is currently called from somewhere other than an RT thread.
1195 This save_state() call therefore doesn't impact anything. Doing it here
1196 means that we save pending state of which sources the next record will use,
1197 which gives us some chance of recovering from a crash during the record.
1200 save_state ("", true);
1202 if (_transport_speed) {
1203 if (!config.get_punch_in()) {
1207 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1208 RecordStateChanged (); /* EMIT SIGNAL */
1215 Session::audible_frame () const
1221 /* the first of these two possible settings for "offset"
1222 mean that the audible frame is stationary until
1223 audio emerges from the latency compensation
1226 the second means that the audible frame is stationary
1227 until audio would emerge from a physical port
1228 in the absence of any plugin latency compensation
1231 offset = worst_playback_latency ();
1233 if (offset > current_block_size) {
1234 offset -= current_block_size;
1236 /* XXX is this correct? if we have no external
1237 physical connections and everything is internal
1238 then surely this is zero? still, how
1239 likely is that anyway?
1241 offset = current_block_size;
1244 if (synced_to_jack()) {
1245 tf = _engine.transport_frame();
1247 tf = _transport_frame;
1252 if (!non_realtime_work_pending()) {
1256 /* Check to see if we have passed the first guaranteed
1257 audible frame past our last start position. if not,
1258 return that last start point because in terms
1259 of audible frames, we have not moved yet.
1261 `Start position' in this context means the time we last
1262 either started, located, or changed transport direction.
1265 if (_transport_speed > 0.0f) {
1267 if (!play_loop || !have_looped) {
1268 if (tf < _last_roll_or_reversal_location + offset) {
1269 return _last_roll_or_reversal_location;
1277 } else if (_transport_speed < 0.0f) {
1279 /* XXX wot? no backward looping? */
1281 if (tf > _last_roll_or_reversal_location - offset) {
1282 return _last_roll_or_reversal_location;
1294 Session::set_frame_rate (framecnt_t frames_per_second)
1296 /** \fn void Session::set_frame_size(framecnt_t)
1297 the AudioEngine object that calls this guarantees
1298 that it will not be called while we are also in
1299 ::process(). Its fine to do things that block
1303 _base_frame_rate = frames_per_second;
1307 Automatable::set_automation_interval (ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
1311 // XXX we need some equivalent to this, somehow
1312 // SndFileSource::setup_standard_crossfades (frames_per_second);
1316 /* XXX need to reset/reinstantiate all LADSPA plugins */
1320 Session::set_block_size (pframes_t nframes)
1322 /* the AudioEngine guarantees
1323 that it will not be called while we are also in
1324 ::process(). It is therefore fine to do things that block
1329 current_block_size = nframes;
1333 boost::shared_ptr<RouteList> r = routes.reader ();
1335 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1336 (*i)->set_block_size (nframes);
1339 boost::shared_ptr<RouteList> rl = routes.reader ();
1340 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1341 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1343 tr->set_block_size (nframes);
1347 set_worst_io_latencies ();
1353 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1355 boost::shared_ptr<Route> r2;
1357 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1358 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1362 /* make a copy of the existing list of routes that feed r1 */
1364 Route::FedBy existing (r1->fed_by());
1366 /* for each route that feeds r1, recurse, marking it as feeding
1370 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1371 if (!(r2 = i->r.lock ())) {
1372 /* (*i) went away, ignore it */
1376 /* r2 is a route that feeds r1 which somehow feeds base. mark
1377 base as being fed by r2
1380 rbase->add_fed_by (r2, i->sends_only);
1384 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1388 if (r1->feeds (r2) && r2->feeds (r1)) {
1392 /* now recurse, so that we can mark base as being fed by
1393 all routes that feed r2
1396 trace_terminal (r2, rbase);
1403 Session::resort_routes ()
1405 /* don't do anything here with signals emitted
1406 by Routes during initial setup or while we
1407 are being destroyed.
1410 if (_state_of_the_state & (InitialConnecting | Deletion)) {
1415 RCUWriter<RouteList> writer (routes);
1416 boost::shared_ptr<RouteList> r = writer.get_copy ();
1417 resort_routes_using (r);
1418 /* writer goes out of scope and forces update */
1422 boost::shared_ptr<RouteList> rl = routes.reader ();
1423 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1424 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1426 const Route::FedBy& fb ((*i)->fed_by());
1428 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1429 boost::shared_ptr<Route> sf = f->r.lock();
1431 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1439 /** This is called whenever we need to rebuild the graph of how we will process
1441 * @param r List of routes, in any order.
1445 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1447 /* We are going to build a directed graph of our routes;
1448 this is where the edges of that graph are put.
1453 /* Go through all routes doing two things:
1455 * 1. Collect the edges of the route graph. Each of these edges
1456 * is a pair of routes, one of which directly feeds the other
1457 * either by a JACK connection or by an internal send.
1459 * 2. Begin the process of making routes aware of which other
1460 * routes directly or indirectly feed them. This information
1461 * is used by the solo code.
1464 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1466 /* Clear out the route's list of direct or indirect feeds */
1467 (*i)->clear_fed_by ();
1469 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1471 bool via_sends_only;
1473 /* See if this *j feeds *i according to the current state of the JACK
1474 connections and internal sends.
1476 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1477 /* add the edge to the graph (part #1) */
1478 edges.add (*j, *i, via_sends_only);
1479 /* tell the route (for part #2) */
1480 (*i)->add_fed_by (*j, via_sends_only);
1485 /* Attempt a topological sort of the route graph */
1486 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1488 if (sorted_routes) {
1489 /* We got a satisfactory topological sort, so there is no feedback;
1492 Note: the process graph rechain does not require a
1493 topologically-sorted list, but hey ho.
1495 if (_process_graph) {
1496 _process_graph->rechain (sorted_routes, edges);
1499 _current_route_graph = edges;
1501 /* Complete the building of the routes' lists of what directly
1502 or indirectly feeds them.
1504 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1505 trace_terminal (*i, *i);
1508 *r = *sorted_routes;
1511 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1512 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1513 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1514 (*i)->name(), (*i)->order_key (MixerSort)));
1518 SuccessfulGraphSort (); /* EMIT SIGNAL */
1521 /* The topological sort failed, so we have a problem. Tell everyone
1522 and stick to the old graph; this will continue to be processed, so
1523 until the feedback is fixed, what is played back will not quite
1524 reflect what is actually connected. Note also that we do not
1525 do trace_terminal here, as it would fail due to an endless recursion,
1526 so the solo code will think that everything is still connected
1530 FeedbackDetected (); /* EMIT SIGNAL */
1535 /** Find a route name starting with \a base, maybe followed by the
1536 * lowest \a id. \a id will always be added if \a definitely_add_number
1537 * is true on entry; otherwise it will only be added if required
1538 * to make the name unique.
1540 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1541 * The available route name with the lowest ID will be used, and \a id
1542 * will be set to the ID.
1544 * \return false if a route name could not be found, and \a track_name
1545 * and \a id do not reflect a free route name.
1548 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1550 if (!definitely_add_number && route_by_name (base) == 0) {
1551 /* juse use the base */
1552 snprintf (name, name_len, "%s", base.c_str());
1557 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1559 if (route_by_name (name) == 0) {
1565 } while (id < (UINT_MAX-1));
1570 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1572 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1574 in = ChanCount::ZERO;
1575 out = ChanCount::ZERO;
1577 boost::shared_ptr<RouteList> r = routes.reader ();
1579 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1580 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1581 if (tr && !tr->is_hidden()) {
1582 in += tr->n_inputs();
1583 out += tr->n_outputs();
1588 /** Caller must not hold process lock
1589 * @param name_template string to use for the start of the name, or "" to use "MIDI".
1590 * @param instrument plugin info for the instrument to insert pre-fader, if any
1592 list<boost::shared_ptr<MidiTrack> >
1593 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1594 TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1596 char track_name[32];
1597 uint32_t track_id = 0;
1599 RouteList new_routes;
1600 list<boost::shared_ptr<MidiTrack> > ret;
1602 cerr << "Adding MIDI track with in = " << input << " out = " << output << endl;
1604 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1607 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1608 error << "cannot find name for new midi track" << endmsg;
1612 boost::shared_ptr<MidiTrack> track;
1615 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1617 if (track->init ()) {
1621 track->use_new_diskstream();
1623 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1624 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1627 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1628 if (track->input()->ensure_io (input, false, this)) {
1629 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1633 if (track->output()->ensure_io (output, false, this)) {
1634 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1639 track->non_realtime_input_change();
1642 route_group->add (track);
1645 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1647 if (Config->get_remote_model() == UserOrdered) {
1648 track->set_remote_control_id (next_control_id());
1651 new_routes.push_back (track);
1652 ret.push_back (track);
1655 catch (failed_constructor &err) {
1656 error << _("Session: could not create new midi track.") << endmsg;
1660 catch (AudioEngine::PortRegistrationFailure& pfe) {
1662 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;
1670 if (!new_routes.empty()) {
1671 add_routes (new_routes, true, true, true);
1674 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1675 PluginPtr plugin = instrument->load (*this);
1676 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1677 (*r)->add_processor (p, PreFader);
1687 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1689 boost::shared_ptr<Route> midi_track (wmt.lock());
1695 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1697 if (change.after.n_audio() <= change.before.n_audio()) {
1701 /* new audio ports: make sure the audio goes somewhere useful,
1702 unless the user has no-auto-connect selected.
1704 The existing ChanCounts don't matter for this call as they are only
1705 to do with matching input and output indices, and we are only changing
1711 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1715 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1716 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1717 * @param output_start As \a input_start, but for outputs.
1720 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1721 bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1723 if (!IO::connecting_legal) {
1727 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
1733 /* If both inputs and outputs are auto-connected to physical ports,
1734 use the max of input and output offsets to ensure auto-connected
1735 port numbers always match up (e.g. the first audio input and the
1736 first audio output of the route will have the same physical
1737 port number). Otherwise just use the lowest input or output
1741 DEBUG_TRACE (DEBUG::Graph,
1742 string_compose("Auto-connect: existing in = %1 out = %2\n",
1743 existing_inputs, existing_outputs));
1745 const bool in_out_physical =
1746 (Config->get_input_auto_connect() & AutoConnectPhysical)
1747 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1750 const ChanCount in_offset = in_out_physical
1751 ? ChanCount::max(existing_inputs, existing_outputs)
1754 const ChanCount out_offset = in_out_physical
1755 ? ChanCount::max(existing_inputs, existing_outputs)
1758 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1759 vector<string> physinputs;
1760 vector<string> physoutputs;
1762 _engine.get_physical_outputs (*t, physoutputs);
1763 _engine.get_physical_inputs (*t, physinputs);
1765 if (!physinputs.empty() && connect_inputs) {
1766 uint32_t nphysical_in = physinputs.size();
1768 DEBUG_TRACE (DEBUG::Graph,
1769 string_compose("There are %1 physical inputs of type %2\n",
1772 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1775 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1776 DEBUG_TRACE (DEBUG::Graph,
1777 string_compose("Get index %1 + %2 % %3 = %4\n",
1778 in_offset.get(*t), i, nphysical_in,
1779 (in_offset.get(*t) + i) % nphysical_in));
1780 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1783 DEBUG_TRACE (DEBUG::Graph,
1784 string_compose("Connect route %1 IN to %2\n",
1785 route->name(), port));
1787 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1791 ChanCount one_added (*t, 1);
1792 existing_inputs += one_added;
1796 if (!physoutputs.empty()) {
1797 uint32_t nphysical_out = physoutputs.size();
1798 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1801 if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
1802 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1803 } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
1804 /* master bus is audio only */
1805 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1806 port = _master_out->input()->ports().port(*t,
1807 i % _master_out->input()->n_ports().get(*t))->name();
1811 DEBUG_TRACE (DEBUG::Graph,
1812 string_compose("Connect route %1 OUT to %2\n",
1813 route->name(), port));
1815 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
1819 ChanCount one_added (*t, 1);
1820 existing_outputs += one_added;
1826 /** Caller must not hold process lock
1827 * @param name_template string to use for the start of the name, or "" to use "Audio".
1829 list< boost::shared_ptr<AudioTrack> >
1830 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
1831 uint32_t how_many, string name_template)
1833 char track_name[32];
1834 uint32_t track_id = 0;
1836 RouteList new_routes;
1837 list<boost::shared_ptr<AudioTrack> > ret;
1839 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
1842 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1843 error << "cannot find name for new audio track" << endmsg;
1847 boost::shared_ptr<AudioTrack> track;
1850 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
1852 if (track->init ()) {
1856 track->use_new_diskstream();
1858 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1859 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1862 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1864 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1865 error << string_compose (
1866 _("cannot configure %1 in/%2 out configuration for new audio track"),
1867 input_channels, output_channels)
1872 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1873 error << string_compose (
1874 _("cannot configure %1 in/%2 out configuration for new audio track"),
1875 input_channels, output_channels)
1882 route_group->add (track);
1885 track->non_realtime_input_change();
1887 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1888 if (Config->get_remote_model() == UserOrdered) {
1889 track->set_remote_control_id (next_control_id());
1892 new_routes.push_back (track);
1893 ret.push_back (track);
1896 catch (failed_constructor &err) {
1897 error << _("Session: could not create new audio track.") << endmsg;
1901 catch (AudioEngine::PortRegistrationFailure& pfe) {
1903 error << pfe.what() << endmsg;
1911 if (!new_routes.empty()) {
1912 add_routes (new_routes, true, true, true);
1918 /** Caller must not hold process lock.
1919 * @param name_template string to use for the start of the name, or "" to use "Bus".
1922 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
1925 uint32_t bus_id = 0;
1929 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
1932 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
1933 error << "cannot find name for new audio bus" << endmsg;
1938 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
1944 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1945 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
1948 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1950 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1951 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1952 input_channels, output_channels)
1958 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1959 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1960 input_channels, output_channels)
1967 route_group->add (bus);
1969 if (Config->get_remote_model() == UserOrdered) {
1970 bus->set_remote_control_id (next_control_id());
1973 bus->add_internal_return ();
1975 ret.push_back (bus);
1979 catch (failed_constructor &err) {
1980 error << _("Session: could not create new audio route.") << endmsg;
1984 catch (AudioEngine::PortRegistrationFailure& pfe) {
1985 error << pfe.what() << endmsg;
1995 add_routes (ret, false, true, true); // autoconnect outputs only
2003 Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
2006 uint32_t control_id;
2008 uint32_t number = 0;
2010 if (!tree.read (template_path.c_str())) {
2014 XMLNode* node = tree.root();
2016 IO::disable_connecting ();
2018 control_id = next_control_id ();
2022 XMLNode node_copy (*node);
2024 /* Remove IDs of everything so that new ones are used */
2025 node_copy.remove_property_recursively (X_("id"));
2028 string const route_name = node_copy.property(X_("name"))->value ();
2030 /* generate a new name by adding a number to the end of the template name */
2032 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2033 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2037 /* set this name in the XML description that we are about to use */
2038 Route::set_name_in_state (node_copy, name);
2040 /* trim bitslots from listen sends so that new ones are used */
2041 XMLNodeList children = node_copy.children ();
2042 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2043 if ((*i)->name() == X_("Processor")) {
2044 XMLProperty* role = (*i)->property (X_("role"));
2045 if (role && role->value() == X_("Listen")) {
2046 (*i)->remove_property (X_("bitslot"));
2051 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2054 error << _("Session: cannot create track/bus from template description") << endmsg;
2058 if (boost::dynamic_pointer_cast<Track>(route)) {
2059 /* force input/output change signals so that the new diskstream
2060 picks up the configuration of the route. During session
2061 loading this normally happens in a different way.
2064 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2066 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2067 change.after = route->input()->n_ports();
2068 route->input()->changed (change, this);
2069 change.after = route->output()->n_ports();
2070 route->output()->changed (change, this);
2073 route->set_remote_control_id (control_id);
2076 ret.push_back (route);
2079 catch (failed_constructor &err) {
2080 error << _("Session: could not create new route from template") << endmsg;
2084 catch (AudioEngine::PortRegistrationFailure& pfe) {
2085 error << pfe.what() << endmsg;
2094 add_routes (ret, true, true, true);
2095 IO::enable_connecting ();
2102 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2104 ChanCount existing_inputs;
2105 ChanCount existing_outputs;
2106 uint32_t order = next_control_id();
2108 count_existing_track_channels (existing_inputs, existing_outputs);
2111 RCUWriter<RouteList> writer (routes);
2112 boost::shared_ptr<RouteList> r = writer.get_copy ();
2113 r->insert (r->end(), new_routes.begin(), new_routes.end());
2115 /* if there is no control out and we're not in the middle of loading,
2116 resort the graph here. if there is a control out, we will resort
2117 toward the end of this method. if we are in the middle of loading,
2118 we will resort when done.
2121 if (!_monitor_out && IO::connecting_legal) {
2122 resort_routes_using (r);
2126 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2128 boost::weak_ptr<Route> wpr (*x);
2129 boost::shared_ptr<Route> r (*x);
2131 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2132 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2133 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2134 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2135 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2136 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2138 if (r->is_master()) {
2142 if (r->is_monitor()) {
2146 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2148 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2149 track_playlist_changed (boost::weak_ptr<Track> (tr));
2150 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2152 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2154 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2155 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2159 if (input_auto_connect || output_auto_connect) {
2160 auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2163 /* order keys are a GUI responsibility but we need to set up
2164 reasonable defaults because they also affect the remote control
2165 ID in most situations.
2168 if (!r->has_order_key (EditorSort)) {
2169 if (r->is_hidden()) {
2170 /* use an arbitrarily high value */
2171 r->set_order_key (EditorSort, UINT_MAX);
2172 r->set_order_key (MixerSort, UINT_MAX);
2174 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2175 r->set_order_key (EditorSort, order);
2176 r->set_order_key (MixerSort, order);
2182 if (_monitor_out && IO::connecting_legal) {
2185 Glib::Mutex::Lock lm (_engine.process_lock());
2187 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2188 if ((*x)->is_monitor()) {
2190 } else if ((*x)->is_master()) {
2193 (*x)->enable_monitor_send ();
2204 save_state (_current_snapshot_name);
2207 RouteAdded (new_routes); /* EMIT SIGNAL */
2208 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
2212 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2214 boost::shared_ptr<RouteList> r = routes.reader ();
2215 boost::shared_ptr<Send> s;
2217 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2218 if ((s = (*i)->internal_send_for (dest)) != 0) {
2219 s->amp()->gain_control()->set_value (0.0);
2225 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2227 boost::shared_ptr<RouteList> r = routes.reader ();
2228 boost::shared_ptr<Send> s;
2230 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2231 if ((s = (*i)->internal_send_for (dest)) != 0) {
2232 s->amp()->gain_control()->set_value (1.0);
2238 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2240 boost::shared_ptr<RouteList> r = routes.reader ();
2241 boost::shared_ptr<Send> s;
2243 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2244 if ((s = (*i)->internal_send_for (dest)) != 0) {
2245 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2250 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2252 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2254 boost::shared_ptr<RouteList> r = routes.reader ();
2255 boost::shared_ptr<RouteList> t (new RouteList);
2257 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2258 /* no MIDI sends because there are no MIDI busses yet */
2259 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2264 add_internal_sends (dest, p, t);
2268 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2270 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2271 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2276 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2278 add_internal_send (dest, sender->before_processor_for_index (index), sender);
2282 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2284 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2288 if (!dest->internal_return()) {
2289 dest->add_internal_return ();
2292 sender->add_aux_send (dest, before);
2298 Session::remove_route (boost::shared_ptr<Route> route)
2300 if (route == _master_out) {
2304 route->set_solo (false, this);
2307 RCUWriter<RouteList> writer (routes);
2308 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2312 /* deleting the master out seems like a dumb
2313 idea, but its more of a UI policy issue
2317 if (route == _master_out) {
2318 _master_out = boost::shared_ptr<Route> ();
2321 if (route == _monitor_out) {
2322 _monitor_out.reset ();
2325 /* writer goes out of scope, forces route list update */
2328 update_route_solo_state ();
2330 // We need to disconnect the route's inputs and outputs
2332 route->input()->disconnect (0);
2333 route->output()->disconnect (0);
2335 /* if the route had internal sends sending to it, remove them */
2336 if (route->internal_return()) {
2338 boost::shared_ptr<RouteList> r = routes.reader ();
2339 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2340 boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2342 (*i)->remove_processor (s);
2347 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2348 if (mt && mt->step_editing()) {
2349 if (_step_editors > 0) {
2354 update_latency_compensation ();
2357 /* Re-sort routes to remove the graph's current references to the one that is
2358 * going away, then flush old references out of the graph.
2362 if (_process_graph) {
2363 _process_graph->clear_other_chain ();
2366 /* get rid of it from the dead wood collection in the route list manager */
2368 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2372 /* try to cause everyone to drop their references */
2374 route->drop_references ();
2376 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2378 /* save the new state of the world */
2380 if (save_state (_current_snapshot_name)) {
2381 save_history (_current_snapshot_name);
2386 Session::route_mute_changed (void* /*src*/)
2392 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2394 boost::shared_ptr<Route> route = wpr.lock();
2396 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2400 if (route->listening_via_monitor ()) {
2402 if (Config->get_exclusive_solo()) {
2403 /* new listen: disable all other listen */
2404 boost::shared_ptr<RouteList> r = routes.reader ();
2405 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2406 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2409 (*i)->set_listen (false, this);
2415 } else if (_listen_cnt > 0) {
2420 update_route_solo_state ();
2423 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2425 boost::shared_ptr<Route> route = wpr.lock ();
2428 /* should not happen */
2429 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2433 bool send_changed = false;
2435 if (route->solo_isolated()) {
2436 if (_solo_isolated_cnt == 0) {
2437 send_changed = true;
2439 _solo_isolated_cnt++;
2440 } else if (_solo_isolated_cnt > 0) {
2441 _solo_isolated_cnt--;
2442 if (_solo_isolated_cnt == 0) {
2443 send_changed = true;
2448 IsolatedChanged (); /* EMIT SIGNAL */
2453 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2455 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2457 if (!self_solo_change) {
2458 // session doesn't care about changes to soloed-by-others
2462 if (solo_update_disabled) {
2464 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2468 boost::shared_ptr<Route> route = wpr.lock ();
2471 boost::shared_ptr<RouteList> r = routes.reader ();
2474 if (route->self_soloed()) {
2480 RouteGroup* rg = route->route_group ();
2481 bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2483 if (delta == 1 && Config->get_exclusive_solo()) {
2485 /* new solo: disable all other solos, but not the group if its solo-enabled */
2487 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2488 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2489 (leave_group_alone && ((*i)->route_group() == rg))) {
2492 (*i)->set_solo (false, this);
2496 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2498 solo_update_disabled = true;
2500 RouteList uninvolved;
2502 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2504 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2505 bool via_sends_only;
2506 bool in_signal_flow;
2508 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2509 (leave_group_alone && ((*i)->route_group() == rg))) {
2513 in_signal_flow = false;
2515 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2517 if ((*i)->feeds (route, &via_sends_only)) {
2518 if (!via_sends_only) {
2519 if (!route->soloed_by_others_upstream()) {
2520 (*i)->mod_solo_by_others_downstream (delta);
2523 in_signal_flow = true;
2525 DEBUG_TRACE (DEBUG::Solo, "\tno feed from\n");
2528 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2530 if (route->feeds (*i, &via_sends_only)) {
2531 /* propagate solo upstream only if routing other than
2532 sends is involved, but do consider the other route
2533 (*i) to be part of the signal flow even if only
2536 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2540 route->soloed_by_others_downstream(),
2541 route->soloed_by_others_upstream()));
2542 if (!via_sends_only) {
2543 if (!route->soloed_by_others_downstream()) {
2544 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2545 (*i)->mod_solo_by_others_upstream (delta);
2548 in_signal_flow = true;
2550 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2553 if (!in_signal_flow) {
2554 uninvolved.push_back (*i);
2558 solo_update_disabled = false;
2559 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2561 update_route_solo_state (r);
2563 /* now notify that the mute state of the routes not involved in the signal
2564 pathway of the just-solo-changed route may have altered.
2567 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2568 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1\n", (*i)->name()));
2569 (*i)->mute_changed (this);
2572 SoloChanged (); /* EMIT SIGNAL */
2577 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2579 /* now figure out if anything that matters is soloed (or is "listening")*/
2581 bool something_soloed = false;
2582 uint32_t listeners = 0;
2583 uint32_t isolated = 0;
2586 r = routes.reader();
2589 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2590 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2591 something_soloed = true;
2594 if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
2595 if (Config->get_solo_control_is_listen_control()) {
2598 (*i)->set_listen (false, this);
2602 if ((*i)->solo_isolated()) {
2607 if (something_soloed != _non_soloed_outs_muted) {
2608 _non_soloed_outs_muted = something_soloed;
2609 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2612 _listen_cnt = listeners;
2614 if (isolated != _solo_isolated_cnt) {
2615 _solo_isolated_cnt = isolated;
2616 IsolatedChanged (); /* EMIT SIGNAL */
2620 boost::shared_ptr<RouteList>
2621 Session::get_routes_with_internal_returns() const
2623 boost::shared_ptr<RouteList> r = routes.reader ();
2624 boost::shared_ptr<RouteList> rl (new RouteList);
2626 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2627 if ((*i)->internal_return ()) {
2635 Session::io_name_is_legal (const std::string& name)
2637 boost::shared_ptr<RouteList> r = routes.reader ();
2639 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2640 if ((*i)->name() == name) {
2644 if ((*i)->has_io_processor_named (name)) {
2653 Session::set_exclusive_input_active (boost::shared_ptr<Route> rt, bool /*others_on*/)
2656 vector<string> connections;
2658 PortSet& ps (rt->input()->ports());
2660 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2661 p->get_connections (connections);
2664 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2665 routes_using_input_from (*s, rl);
2668 /* scan all relevant routes to see if others are on or off */
2670 bool others_are_already_on = false;
2672 for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2674 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2676 if (mt->input_active()) {
2677 others_are_already_on = true;
2684 /* globally reverse other routes */
2686 for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
2688 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2690 mt->set_input_active (!others_are_already_on);
2697 Session::routes_using_input_from (const string& str, RouteList& rl)
2699 boost::shared_ptr<RouteList> r = routes.reader ();
2701 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2702 if ((*i)->input()->connected_to (str)) {
2708 boost::shared_ptr<Route>
2709 Session::route_by_name (string name)
2711 boost::shared_ptr<RouteList> r = routes.reader ();
2713 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2714 if ((*i)->name() == name) {
2719 return boost::shared_ptr<Route> ((Route*) 0);
2722 boost::shared_ptr<Route>
2723 Session::route_by_id (PBD::ID id)
2725 boost::shared_ptr<RouteList> r = routes.reader ();
2727 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2728 if ((*i)->id() == id) {
2733 return boost::shared_ptr<Route> ((Route*) 0);
2736 boost::shared_ptr<Track>
2737 Session::track_by_diskstream_id (PBD::ID id)
2739 boost::shared_ptr<RouteList> r = routes.reader ();
2741 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2742 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
2743 if (t && t->using_diskstream_id (id)) {
2748 return boost::shared_ptr<Track> ();
2751 boost::shared_ptr<Route>
2752 Session::route_by_remote_id (uint32_t id)
2754 boost::shared_ptr<RouteList> r = routes.reader ();
2756 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2757 if ((*i)->remote_control_id() == id) {
2762 return boost::shared_ptr<Route> ((Route*) 0);
2766 Session::playlist_region_added (boost::weak_ptr<Region> w)
2768 boost::shared_ptr<Region> r = w.lock ();
2773 /* These are the operations that are currently in progress... */
2774 list<GQuark> curr = _current_trans_quarks;
2777 /* ...and these are the operations during which we want to update
2778 the session range location markers.
2781 ops.push_back (Operations::capture);
2782 ops.push_back (Operations::paste);
2783 ops.push_back (Operations::duplicate_region);
2784 ops.push_back (Operations::insert_file);
2785 ops.push_back (Operations::insert_region);
2786 ops.push_back (Operations::drag_region_brush);
2787 ops.push_back (Operations::region_drag);
2788 ops.push_back (Operations::selection_grab);
2789 ops.push_back (Operations::region_fill);
2790 ops.push_back (Operations::fill_selection);
2791 ops.push_back (Operations::create_region);
2792 ops.push_back (Operations::region_copy);
2793 ops.push_back (Operations::fixed_time_region_copy);
2796 /* See if any of the current operations match the ones that we want */
2798 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2800 /* If so, update the session range markers */
2802 maybe_update_session_range (r->position (), r->last_frame ());
2806 /** Update the session range markers if a is before the current start or
2807 * b is after the current end.
2810 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2812 if (_state_of_the_state & Loading) {
2816 if (_session_range_location == 0) {
2818 add_session_range_location (a, b);
2822 if (a < _session_range_location->start()) {
2823 _session_range_location->set_start (a);
2826 if (b > _session_range_location->end()) {
2827 _session_range_location->set_end (b);
2833 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2835 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2836 maybe_update_session_range (i->to, i->to + i->length);
2841 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2843 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2844 maybe_update_session_range (i->from, i->to);
2848 /* Region management */
2850 boost::shared_ptr<Region>
2851 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2853 const RegionFactory::RegionMap& regions (RegionFactory::regions());
2854 RegionFactory::RegionMap::const_iterator i;
2855 boost::shared_ptr<Region> region;
2857 Glib::Mutex::Lock lm (region_lock);
2859 for (i = regions.begin(); i != regions.end(); ++i) {
2863 if (region->whole_file()) {
2865 if (child->source_equivalent (region)) {
2871 return boost::shared_ptr<Region> ();
2875 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2877 set<boost::shared_ptr<Region> > relevant_regions;
2879 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2880 RegionFactory::get_regions_using_source (*s, relevant_regions);
2883 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2884 set<boost::shared_ptr<Region> >::iterator tmp;
2889 playlists->destroy_region (*r);
2890 RegionFactory::map_remove (*r);
2892 (*r)->drop_sources ();
2893 (*r)->drop_references ();
2895 relevant_regions.erase (r);
2900 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2903 Glib::Mutex::Lock ls (source_lock);
2904 /* remove from the main source list */
2905 sources.erase ((*s)->id());
2908 (*s)->mark_for_remove ();
2909 (*s)->drop_references ();
2918 Session::remove_last_capture ()
2920 list<boost::shared_ptr<Source> > srcs;
2922 boost::shared_ptr<RouteList> rl = routes.reader ();
2923 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2924 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2929 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
2932 srcs.insert (srcs.end(), l.begin(), l.end());
2937 destroy_sources (srcs);
2939 save_state (_current_snapshot_name);
2944 /* Source Management */
2947 Session::add_source (boost::shared_ptr<Source> source)
2949 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
2950 pair<SourceMap::iterator,bool> result;
2952 entry.first = source->id();
2953 entry.second = source;
2956 Glib::Mutex::Lock lm (source_lock);
2957 result = sources.insert (entry);
2960 if (result.second) {
2962 /* yay, new source */
2964 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
2967 if (!fs->within_session()) {
2968 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
2974 boost::shared_ptr<AudioFileSource> afs;
2976 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2977 if (Config->get_auto_analyse_audio()) {
2978 Analyser::queue_source_for_analysis (source, false);
2982 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
2987 Session::remove_source (boost::weak_ptr<Source> src)
2989 if (_state_of_the_state & Deletion) {
2993 SourceMap::iterator i;
2994 boost::shared_ptr<Source> source = src.lock();
3001 Glib::Mutex::Lock lm (source_lock);
3003 if ((i = sources.find (source->id())) != sources.end()) {
3008 if (!(_state_of_the_state & InCleanup)) {
3010 /* save state so we don't end up with a session file
3011 referring to non-existent sources.
3014 save_state (_current_snapshot_name);
3018 boost::shared_ptr<Source>
3019 Session::source_by_id (const PBD::ID& id)
3021 Glib::Mutex::Lock lm (source_lock);
3022 SourceMap::iterator i;
3023 boost::shared_ptr<Source> source;
3025 if ((i = sources.find (id)) != sources.end()) {
3032 boost::shared_ptr<Source>
3033 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3035 Glib::Mutex::Lock lm (source_lock);
3037 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3038 boost::shared_ptr<AudioFileSource> afs
3039 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3041 if (afs && afs->path() == path && chn == afs->channel()) {
3045 return boost::shared_ptr<Source>();
3049 Session::count_sources_by_origin (const string& path)
3052 Glib::Mutex::Lock lm (source_lock);
3054 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3055 boost::shared_ptr<FileSource> fs
3056 = boost::dynamic_pointer_cast<FileSource>(i->second);
3058 if (fs && fs->origin() == path) {
3068 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3071 string old_basename = PBD::basename_nosuffix (oldname);
3072 string new_legalized = legalize_for_path (newname);
3074 /* note: we know (or assume) the old path is already valid */
3078 /* destructive file sources have a name of the form:
3080 /path/to/Tnnnn-NAME(%[LR])?.wav
3082 the task here is to replace NAME with the new name.
3087 string::size_type dash;
3089 dir = Glib::path_get_dirname (path);
3090 path = Glib::path_get_basename (path);
3092 /* '-' is not a legal character for the NAME part of the path */
3094 if ((dash = path.find_last_of ('-')) == string::npos) {
3098 prefix = path.substr (0, dash);
3102 path += new_legalized;
3103 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3104 path = Glib::build_filename (dir, path);
3108 /* non-destructive file sources have a name of the form:
3110 /path/to/NAME-nnnnn(%[LR])?.ext
3112 the task here is to replace NAME with the new name.
3117 string::size_type dash;
3118 string::size_type postfix;
3120 dir = Glib::path_get_dirname (path);
3121 path = Glib::path_get_basename (path);
3123 /* '-' is not a legal character for the NAME part of the path */
3125 if ((dash = path.find_last_of ('-')) == string::npos) {
3129 suffix = path.substr (dash+1);
3131 // Suffix is now everything after the dash. Now we need to eliminate
3132 // the nnnnn part, which is done by either finding a '%' or a '.'
3134 postfix = suffix.find_last_of ("%");
3135 if (postfix == string::npos) {
3136 postfix = suffix.find_last_of ('.');
3139 if (postfix != string::npos) {
3140 suffix = suffix.substr (postfix);
3142 error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3146 const uint32_t limit = 10000;
3147 char buf[PATH_MAX+1];
3149 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3151 snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3153 if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3154 path = Glib::build_filename (dir, buf);
3162 fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3171 /** Return the full path (in some session directory) for a new within-session source.
3172 * \a name must be a session-unique name that does not contain slashes
3173 * (e.g. as returned by new_*_source_name)
3176 Session::new_source_path_from_name (DataType type, const string& name)
3178 assert(name.find("/") == string::npos);
3180 SessionDirectory sdir(get_best_session_directory_for_new_source());
3183 if (type == DataType::AUDIO) {
3184 p = sdir.sound_path();
3185 } else if (type == DataType::MIDI) {
3186 p = sdir.midi_path();
3188 error << "Unknown source type, unable to create file path" << endmsg;
3192 return Glib::build_filename (p, name);
3196 Session::peak_path (string base) const
3198 return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3201 /** Return a unique name based on \a base for a new internal audio source */
3203 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3206 char buf[PATH_MAX+1];
3207 const uint32_t limit = 10000;
3209 string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3212 legalized = legalize_for_path (base);
3214 // Find a "version" of the base name that doesn't exist in any of the possible directories.
3215 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3217 vector<space_and_path>::iterator i;
3218 uint32_t existing = 0;
3220 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3225 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3226 cnt, legalized.c_str(), ext.c_str());
3227 } else if (nchan == 2) {
3229 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3230 cnt, legalized.c_str(), ext.c_str());
3232 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3233 cnt, legalized.c_str(), ext.c_str());
3235 } else if (nchan < 26) {
3236 snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3237 cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3239 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3240 cnt, legalized.c_str(), ext.c_str());
3246 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3247 } else if (nchan == 2) {
3249 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3251 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3253 } else if (nchan < 26) {
3254 snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3256 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3260 SessionDirectory sdir((*i).path);
3262 string spath = sdir.sound_path();
3264 /* note that we search *without* the extension so that
3265 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3266 in the event that this new name is required for
3267 a file format change.
3270 if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3276 if (existing == 0) {
3281 error << string_compose(
3282 _("There are already %1 recordings for %2, which I consider too many."),
3283 limit, base) << endmsg;
3285 throw failed_constructor();
3289 return Glib::path_get_basename (buf);
3292 /** Create a new within-session audio source */
3293 boost::shared_ptr<AudioFileSource>
3294 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3296 const string name = new_audio_source_name (n, n_chans, chan, destructive);
3297 const string path = new_source_path_from_name(DataType::AUDIO, name);
3299 return boost::dynamic_pointer_cast<AudioFileSource> (
3300 SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
3303 /** Return a unique name based on \a base for a new internal MIDI source */
3305 Session::new_midi_source_name (const string& base)
3308 char buf[PATH_MAX+1];
3309 const uint32_t limit = 10000;
3313 legalized = legalize_for_path (base);
3315 // Find a "version" of the file name that doesn't exist in any of the possible directories.
3316 for (cnt = 1; cnt <= limit; ++cnt) {
3318 vector<space_and_path>::iterator i;
3319 uint32_t existing = 0;
3321 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3323 SessionDirectory sdir((*i).path);
3325 std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3327 snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3329 if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3334 if (existing == 0) {
3339 error << string_compose(
3340 _("There are already %1 recordings for %2, which I consider too many."),
3341 limit, base) << endmsg;
3343 throw failed_constructor();
3347 return Glib::path_get_basename(buf);
3351 /** Create a new within-session MIDI source */
3352 boost::shared_ptr<MidiSource>
3353 Session::create_midi_source_for_session (Track* track, string const & n)
3355 /* try to use the existing write source for the track, to keep numbering sane
3359 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3363 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3366 assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3367 return boost::dynamic_pointer_cast<MidiSource> (l.front());
3371 const string name = new_midi_source_name (n);
3372 const string path = new_source_path_from_name (DataType::MIDI, name);
3374 return boost::dynamic_pointer_cast<SMFSource> (
3375 SourceFactory::createWritable (
3376 DataType::MIDI, *this, path, string(), false, frame_rate()));
3381 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3383 if (playlist->hidden()) {
3387 playlists->add (playlist);
3390 playlist->release();
3397 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3399 if (_state_of_the_state & Deletion) {
3403 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3409 playlists->remove (playlist);
3415 Session::set_audition (boost::shared_ptr<Region> r)
3417 pending_audition_region = r;
3418 add_post_transport_work (PostTransportAudition);
3419 _butler->schedule_transport_work ();
3423 Session::audition_playlist ()
3425 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3426 ev->region.reset ();
3431 Session::non_realtime_set_audition ()
3433 assert (pending_audition_region);
3434 auditioner->audition_region (pending_audition_region);
3435 pending_audition_region.reset ();
3436 AuditionActive (true); /* EMIT SIGNAL */
3440 Session::audition_region (boost::shared_ptr<Region> r)
3442 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3448 Session::cancel_audition ()
3450 if (auditioner->auditioning()) {
3451 auditioner->cancel_audition ();
3452 AuditionActive (false); /* EMIT SIGNAL */
3457 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3459 if (a->is_monitor()) {
3462 if (b->is_monitor()) {
3465 return a->order_key (MixerSort) < b->order_key (MixerSort);
3469 Session::is_auditioning () const
3471 /* can be called before we have an auditioner object */
3473 return auditioner->auditioning();
3480 Session::graph_reordered ()
3482 /* don't do this stuff if we are setting up connections
3483 from a set_state() call or creating new tracks. Ditto for deletion.
3486 if (_state_of_the_state & (InitialConnecting|Deletion)) {
3490 /* every track/bus asked for this to be handled but it was deferred because
3491 we were connecting. do it now.
3494 request_input_change_handling ();
3498 /* force all diskstreams to update their capture offset values to
3499 reflect any changes in latencies within the graph.
3502 boost::shared_ptr<RouteList> rl = routes.reader ();
3503 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3504 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3506 tr->set_capture_offset ();
3511 /** @return Number of frames that there is disk space available to write,
3514 boost::optional<framecnt_t>
3515 Session::available_capture_duration ()
3517 Glib::Mutex::Lock lm (space_lock);
3519 if (_total_free_4k_blocks_uncertain) {
3520 return boost::optional<framecnt_t> ();
3523 float sample_bytes_on_disk = 4.0; // keep gcc happy
3525 switch (config.get_native_file_data_format()) {
3527 sample_bytes_on_disk = 4.0;
3531 sample_bytes_on_disk = 3.0;
3535 sample_bytes_on_disk = 2.0;
3539 /* impossible, but keep some gcc versions happy */
3540 fatal << string_compose (_("programming error: %1"),
3541 X_("illegal native file data format"))
3546 double scale = 4096.0 / sample_bytes_on_disk;
3548 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3549 return max_framecnt;
3552 return (framecnt_t) floor (_total_free_4k_blocks * scale);
3556 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3559 RCUWriter<BundleList> writer (_bundles);
3560 boost::shared_ptr<BundleList> b = writer.get_copy ();
3561 b->push_back (bundle);
3564 BundleAdded (bundle); /* EMIT SIGNAL */
3570 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3572 bool removed = false;
3575 RCUWriter<BundleList> writer (_bundles);
3576 boost::shared_ptr<BundleList> b = writer.get_copy ();
3577 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3579 if (i != b->end()) {
3586 BundleRemoved (bundle); /* EMIT SIGNAL */
3592 boost::shared_ptr<Bundle>
3593 Session::bundle_by_name (string name) const
3595 boost::shared_ptr<BundleList> b = _bundles.reader ();
3597 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3598 if ((*i)->name() == name) {
3603 return boost::shared_ptr<Bundle> ();
3607 Session::tempo_map_changed (const PropertyChange&)
3611 playlists->update_after_tempo_map_change ();
3613 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3619 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3621 for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3622 (*i)->recompute_frames_from_bbt ();
3626 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3627 * the given count with the current block size.
3630 Session::ensure_buffers (ChanCount howmany)
3632 BufferManager::ensure_buffers (howmany);
3636 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3638 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3639 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3644 Session::next_insert_id ()
3646 /* this doesn't really loop forever. just think about it */
3649 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3650 if (!insert_bitset[n]) {
3651 insert_bitset[n] = true;
3657 /* none available, so resize and try again */
3659 insert_bitset.resize (insert_bitset.size() + 16, false);
3664 Session::next_send_id ()
3666 /* this doesn't really loop forever. just think about it */
3669 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3670 if (!send_bitset[n]) {
3671 send_bitset[n] = true;
3677 /* none available, so resize and try again */
3679 send_bitset.resize (send_bitset.size() + 16, false);
3684 Session::next_aux_send_id ()
3686 /* this doesn't really loop forever. just think about it */
3689 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3690 if (!aux_send_bitset[n]) {
3691 aux_send_bitset[n] = true;
3697 /* none available, so resize and try again */
3699 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3704 Session::next_return_id ()
3706 /* this doesn't really loop forever. just think about it */
3709 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3710 if (!return_bitset[n]) {
3711 return_bitset[n] = true;
3717 /* none available, so resize and try again */
3719 return_bitset.resize (return_bitset.size() + 16, false);
3724 Session::mark_send_id (uint32_t id)
3726 if (id >= send_bitset.size()) {
3727 send_bitset.resize (id+16, false);
3729 if (send_bitset[id]) {
3730 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3732 send_bitset[id] = true;
3736 Session::mark_aux_send_id (uint32_t id)
3738 if (id >= aux_send_bitset.size()) {
3739 aux_send_bitset.resize (id+16, false);
3741 if (aux_send_bitset[id]) {
3742 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3744 aux_send_bitset[id] = true;
3748 Session::mark_return_id (uint32_t id)
3750 if (id >= return_bitset.size()) {
3751 return_bitset.resize (id+16, false);
3753 if (return_bitset[id]) {
3754 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3756 return_bitset[id] = true;
3760 Session::mark_insert_id (uint32_t id)
3762 if (id >= insert_bitset.size()) {
3763 insert_bitset.resize (id+16, false);
3765 if (insert_bitset[id]) {
3766 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3768 insert_bitset[id] = true;
3772 Session::unmark_send_id (uint32_t id)
3774 if (id < send_bitset.size()) {
3775 send_bitset[id] = false;
3780 Session::unmark_aux_send_id (uint32_t id)
3782 if (id < aux_send_bitset.size()) {
3783 aux_send_bitset[id] = false;
3788 Session::unmark_return_id (uint32_t id)
3790 if (id < return_bitset.size()) {
3791 return_bitset[id] = false;
3796 Session::unmark_insert_id (uint32_t id)
3798 if (id < insert_bitset.size()) {
3799 insert_bitset[id] = false;
3804 Session::reset_native_file_format ()
3806 boost::shared_ptr<RouteList> rl = routes.reader ();
3807 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3808 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3810 /* don't save state as we do this, there's no point
3813 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3814 tr->reset_write_sources (false);
3815 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3821 Session::route_name_unique (string n) const
3823 boost::shared_ptr<RouteList> r = routes.reader ();
3825 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3826 if ((*i)->name() == n) {
3835 Session::route_name_internal (string n) const
3837 if (auditioner && auditioner->name() == n) {
3841 if (_click_io && _click_io->name() == n) {
3849 Session::freeze_all (InterThreadInfo& itt)
3851 boost::shared_ptr<RouteList> r = routes.reader ();
3853 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3855 boost::shared_ptr<Track> t;
3857 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3858 /* XXX this is wrong because itt.progress will keep returning to zero at the start
3868 boost::shared_ptr<Region>
3869 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3870 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3871 InterThreadInfo& itt,
3872 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
3875 boost::shared_ptr<Region> result;
3876 boost::shared_ptr<Playlist> playlist;
3877 boost::shared_ptr<AudioFileSource> fsource;
3879 char buf[PATH_MAX+1];
3880 ChanCount diskstream_channels (track.n_channels());
3881 framepos_t position;
3882 framecnt_t this_chunk;
3885 SessionDirectory sdir(get_best_session_directory_for_new_source ());
3886 const string sound_dir = sdir.sound_path();
3887 framepos_t len = end - start;
3888 bool need_block_size_reset = false;
3890 ChanCount const max_proc = track.max_processor_streams ();
3893 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3894 end, start) << endmsg;
3898 const framecnt_t chunk_size = (256 * 1024)/4;
3900 // block all process callback handling
3902 block_processing ();
3904 /* call tree *MUST* hold route_lock */
3906 if ((playlist = track.playlist()) == 0) {
3910 ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3912 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3914 for (x = 0; x < 99999; ++x) {
3915 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());
3916 if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3922 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3927 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3928 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
3931 catch (failed_constructor& err) {
3932 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3936 srcs.push_back (fsource);
3939 /* tell redirects that care that we are about to use a much larger
3940 * blocksize. this will flush all plugins too, so that they are ready
3941 * to be used for this process.
3944 need_block_size_reset = true;
3945 track.set_block_size (chunk_size);
3950 /* create a set of reasonably-sized buffers */
3951 buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
3952 buffers.set_count (max_proc);
3954 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3955 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3957 afs->prepare_for_peakfile_writes ();
3960 while (to_do && !itt.cancel) {
3962 this_chunk = min (to_do, chunk_size);
3964 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
3969 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3970 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3973 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
3979 start += this_chunk;
3980 to_do -= this_chunk;
3982 itt.progress = (float) (1.0 - ((double) to_do / len));
3991 xnow = localtime (&now);
3993 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3994 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3997 afs->update_header (position, *xnow, now);
3998 afs->flush_header ();
4002 /* construct a region to represent the bounced material */
4006 plist.add (Properties::start, 0);
4007 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4008 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4010 result = RegionFactory::create (srcs, plist);
4016 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4017 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4020 afs->mark_for_remove ();
4023 (*src)->drop_references ();
4027 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4028 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4031 afs->done_with_peakfile_writes ();
4036 if (need_block_size_reset) {
4037 track.set_block_size (get_block_size());
4040 unblock_processing ();
4046 Session::gain_automation_buffer() const
4048 return ProcessThread::gain_automation_buffer ();
4052 Session::send_gain_automation_buffer() const
4054 return ProcessThread::send_gain_automation_buffer ();
4058 Session::pan_automation_buffer() const
4060 return ProcessThread::pan_automation_buffer ();
4064 Session::get_silent_buffers (ChanCount count)
4066 return ProcessThread::get_silent_buffers (count);
4070 Session::get_scratch_buffers (ChanCount count)
4072 return ProcessThread::get_scratch_buffers (count);
4076 Session::get_mix_buffers (ChanCount count)
4078 return ProcessThread::get_mix_buffers (count);
4082 Session::ntracks () const
4085 boost::shared_ptr<RouteList> r = routes.reader ();
4087 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4088 if (boost::dynamic_pointer_cast<Track> (*i)) {
4097 Session::nbusses () const
4100 boost::shared_ptr<RouteList> r = routes.reader ();
4102 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4103 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4112 Session::add_automation_list(AutomationList *al)
4114 automation_lists[al->id()] = al;
4117 /** @return true if there is at least one record-enabled track, otherwise false */
4119 Session::have_rec_enabled_track () const
4121 return g_atomic_int_get (&_have_rec_enabled_track) == 1;
4124 /** Update the state of our rec-enabled tracks flag */
4126 Session::update_have_rec_enabled_track ()
4128 boost::shared_ptr<RouteList> rl = routes.reader ();
4129 RouteList::iterator i = rl->begin();
4130 while (i != rl->end ()) {
4132 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4133 if (tr && tr->record_enabled ()) {
4140 int const old = g_atomic_int_get (&_have_rec_enabled_track);
4142 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4144 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4145 RecordStateChanged (); /* EMIT SIGNAL */
4150 Session::listen_position_changed ()
4152 boost::shared_ptr<RouteList> r = routes.reader ();
4154 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4155 (*i)->listen_position_changed ();
4160 Session::solo_control_mode_changed ()
4162 /* cancel all solo or all listen when solo control mode changes */
4165 set_solo (get_routes(), false);
4166 } else if (listening()) {
4167 set_listen (get_routes(), false);
4171 /** Called when a property of one of our route groups changes */
4173 Session::route_group_property_changed (RouteGroup* rg)
4175 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4178 /** Called when a route is added to one of our route groups */
4180 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4182 RouteAddedToRouteGroup (rg, r);
4185 /** Called when a route is removed from one of our route groups */
4187 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4189 RouteRemovedFromRouteGroup (rg, r);
4193 Session::get_available_sync_options () const
4195 vector<SyncSource> ret;
4197 ret.push_back (JACK);
4198 ret.push_back (MTC);
4199 ret.push_back (MIDIClock);
4204 boost::shared_ptr<RouteList>
4205 Session::get_routes_with_regions_at (framepos_t const p) const
4207 boost::shared_ptr<RouteList> r = routes.reader ();
4208 boost::shared_ptr<RouteList> rl (new RouteList);
4210 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4211 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4216 boost::shared_ptr<Playlist> pl = tr->playlist ();
4221 if (pl->has_region_at (p)) {
4230 Session::goto_end ()
4232 if (_session_range_location) {
4233 request_locate (_session_range_location->end(), false);
4235 request_locate (0, false);
4240 Session::goto_start ()
4242 if (_session_range_location) {
4243 request_locate (_session_range_location->start(), false);
4245 request_locate (0, false);
4250 Session::current_start_frame () const
4252 return _session_range_location ? _session_range_location->start() : 0;
4256 Session::current_end_frame () const
4258 return _session_range_location ? _session_range_location->end() : 0;
4262 Session::add_session_range_location (framepos_t start, framepos_t end)
4264 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4265 _locations->add (_session_range_location);
4269 Session::step_edit_status_change (bool yn)
4275 send = (_step_editors == 0);
4280 send = (_step_editors == 1);
4283 if (_step_editors > 0) {
4289 StepEditStatusChange (val);
4295 Session::start_time_changed (framepos_t old)
4297 /* Update the auto loop range to match the session range
4298 (unless the auto loop range has been changed by the user)
4301 Location* s = _locations->session_range_location ();
4306 Location* l = _locations->auto_loop_location ();
4308 if (l && l->start() == old) {
4309 l->set_start (s->start(), true);
4314 Session::end_time_changed (framepos_t old)
4316 /* Update the auto loop range to match the session range
4317 (unless the auto loop range has been changed by the user)
4320 Location* s = _locations->session_range_location ();
4325 Location* l = _locations->auto_loop_location ();
4327 if (l && l->end() == old) {
4328 l->set_end (s->end(), true);
4333 Session::source_search_path (DataType type) const
4337 if (session_dirs.size() == 1) {
4339 case DataType::AUDIO:
4340 s.push_back ( _session_dir->sound_path());
4342 case DataType::MIDI:
4343 s.push_back (_session_dir->midi_path());
4347 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4348 SessionDirectory sdir (i->path);
4350 case DataType::AUDIO:
4351 s.push_back (sdir.sound_path());
4353 case DataType::MIDI:
4354 s.push_back (sdir.midi_path());
4360 /* now check the explicit (possibly user-specified) search path
4363 vector<string> dirs;
4366 case DataType::AUDIO:
4367 split (config.get_audio_search_path (), dirs, ':');
4369 case DataType::MIDI:
4370 split (config.get_midi_search_path (), dirs, ':');
4374 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4376 vector<string>::iterator si;
4378 for (si = s.begin(); si != s.end(); ++si) {
4384 if (si == s.end()) {
4391 for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4392 if (!search_path.empty()) {
4402 Session::ensure_search_path_includes (const string& path, DataType type)
4405 vector<string> dirs;
4412 case DataType::AUDIO:
4413 search_path = config.get_audio_search_path ();
4415 case DataType::MIDI:
4416 search_path = config.get_midi_search_path ();
4420 split (search_path, dirs, ':');
4422 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4423 /* No need to add this new directory if it has the same inode as
4424 an existing one; checking inode rather than name prevents duplicated
4425 directories when we are using symlinks.
4427 On Windows, I think we could just do if (*i == path) here.
4429 if (PBD::equivalent_paths (*i, path)) {
4434 if (!search_path.empty()) {
4438 search_path += path;
4441 case DataType::AUDIO:
4442 config.set_audio_search_path (search_path);
4444 case DataType::MIDI:
4445 config.set_midi_search_path (search_path);
4450 boost::shared_ptr<Speakers>
4451 Session::get_speakers()
4457 Session::unknown_processors () const
4461 boost::shared_ptr<RouteList> r = routes.reader ();
4462 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4463 list<string> t = (*i)->unknown_processors ();
4464 copy (t.begin(), t.end(), back_inserter (p));
4474 Session::update_latency (bool playback)
4476 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4478 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4482 boost::shared_ptr<RouteList> r = routes.reader ();
4483 framecnt_t max_latency = 0;
4486 /* reverse the list so that we work backwards from the last route to run to the first */
4487 RouteList* rl = routes.reader().get();
4488 r.reset (new RouteList (*rl));
4489 reverse (r->begin(), r->end());
4492 /* compute actual latency values for the given direction and store them all in per-port
4493 structures. this will also publish the same values (to JACK) so that computation of latency
4494 for routes can consistently use public latency values.
4497 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4498 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4501 /* because we latency compensate playback, our published playback latencies should
4502 be the same for all output ports - all material played back by ardour has
4503 the same latency, whether its caused by plugins or by latency compensation. since
4504 these may differ from the values computed above, reset all playback port latencies
4508 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4510 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4511 (*i)->set_public_port_latencies (max_latency, playback);
4516 post_playback_latency ();
4520 post_capture_latency ();
4523 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4527 Session::post_playback_latency ()
4529 set_worst_playback_latency ();
4531 boost::shared_ptr<RouteList> r = routes.reader ();
4533 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4534 if (!(*i)->is_hidden() && ((*i)->active())) {
4535 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4539 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4540 (*i)->set_latency_compensation (_worst_track_latency);
4545 Session::post_capture_latency ()
4547 set_worst_capture_latency ();
4549 /* reflect any changes in capture latencies into capture offsets
4552 boost::shared_ptr<RouteList> rl = routes.reader();
4553 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4554 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4556 tr->set_capture_offset ();
4562 Session::initialize_latencies ()
4565 Glib::Mutex::Lock lm (_engine.process_lock());
4566 update_latency (false);
4567 update_latency (true);
4570 set_worst_io_latencies ();
4574 Session::set_worst_io_latencies ()
4576 set_worst_playback_latency ();
4577 set_worst_capture_latency ();
4581 Session::set_worst_playback_latency ()
4583 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4587 _worst_output_latency = 0;
4589 if (!_engine.connected()) {
4593 boost::shared_ptr<RouteList> r = routes.reader ();
4595 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4596 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4599 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4603 Session::set_worst_capture_latency ()
4605 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4609 _worst_input_latency = 0;
4611 if (!_engine.connected()) {
4615 boost::shared_ptr<RouteList> r = routes.reader ();
4617 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4618 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4621 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4625 Session::update_latency_compensation (bool force_whole_graph)
4627 bool some_track_latency_changed = false;
4629 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4633 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4635 _worst_track_latency = 0;
4637 boost::shared_ptr<RouteList> r = routes.reader ();
4639 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4640 if (!(*i)->is_hidden() && ((*i)->active())) {
4642 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4643 some_track_latency_changed = true;
4645 _worst_track_latency = max (tl, _worst_track_latency);
4649 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4650 (some_track_latency_changed ? "yes" : "no")));
4652 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4654 if (some_track_latency_changed || force_whole_graph) {
4655 _engine.update_latencies ();
4659 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4660 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4664 tr->set_capture_offset ();
4669 Session::session_name_is_legal (const string& path)
4671 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4673 for (int i = 0; illegal_chars[i]; ++i) {
4674 if (path.find (illegal_chars[i]) != string::npos) {
4675 return illegal_chars[i];
4683 Session::next_control_id () const
4687 /* the monitor bus remote ID is in a different
4688 * "namespace" than regular routes. its existence doesn't
4689 * affect normal (low) numbered routes.
4696 return nroutes() - subtract;
4700 Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
4702 if (deletion_in_progress()) {
4706 switch (Config->get_remote_model()) {
4709 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4715 /* tell everyone that something has happened to the sort keys
4716 and let them sync up with the change(s)
4719 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
4721 Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
4725 Session::operation_in_progress (GQuark op) const
4727 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());