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/threads.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;
122 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
124 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
125 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
127 /** @param snapshot_name Snapshot name, without .ardour suffix */
128 Session::Session (AudioEngine &eng,
129 const string& fullpath,
130 const string& snapshot_name,
131 BusProfile* bus_profile,
134 , _target_transport_speed (0.0)
135 , _requested_return_frame (-1)
136 , _under_nsm_control (false)
137 , _session_dir (new SessionDirectory(fullpath))
139 , _state_of_the_state (Clean)
140 , _butler (new Butler (*this))
141 , _post_transport_work (0)
142 , _send_timecode_update (false)
143 , _all_route_group (new RouteGroup (*this, "all"))
144 , routes (new RouteList)
145 , _total_free_4k_blocks (0)
146 , _total_free_4k_blocks_uncertain (false)
147 , _bundles (new BundleList)
148 , _bundle_xml_node (0)
151 , click_emphasis_data (0)
153 , _have_rec_enabled_track (false)
154 , _suspend_timecode_transmission (0)
156 _locations = new Locations (*this);
159 if (how_many_dsp_threads () > 1) {
160 /* For now, only create the graph if we are using >1 DSP threads, as
161 it is a bit slower than the old code with 1 thread.
163 _process_graph.reset (new Graph (*this));
166 playlists.reset (new SessionPlaylists);
168 _all_route_group->set_active (true, this);
170 interpolation.add_channel_to (0, 0);
172 if (!eng.connected()) {
173 throw failed_constructor();
176 n_physical_outputs = _engine.n_physical_outputs ();
177 n_physical_inputs = _engine.n_physical_inputs ();
179 first_stage_init (fullpath, snapshot_name);
181 _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
184 if (create (mix_template, bus_profile)) {
186 throw failed_constructor ();
190 if (second_stage_init ()) {
192 throw failed_constructor ();
195 store_recent_sessions(_name, _path);
197 bool was_dirty = dirty();
199 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
201 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
202 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
205 DirtyChanged (); /* EMIT SIGNAL */
208 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
209 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
225 vector<void*> debug_pointers;
227 /* if we got to here, leaving pending capture state around
231 remove_pending_capture_state ();
233 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
235 /* disconnect from any and all signals that we are connected to */
239 _engine.remove_session ();
241 /* deregister all ports - there will be no process or any other
242 * callbacks from the engine any more.
245 Port::PortDrop (); /* EMIT SIGNAL */
249 /* clear history so that no references to objects are held any more */
253 /* clear state tree so that no references to objects are held any more */
257 /* reset dynamic state version back to default */
259 Stateful::loading_state_version = 0;
261 _butler->drop_references ();
265 delete midi_control_ui;
266 delete _all_route_group;
268 if (click_data != default_click) {
269 delete [] click_data;
272 if (click_emphasis_data != default_click_emphasis) {
273 delete [] click_emphasis_data;
278 /* clear out any pending dead wood from RCU managed objects */
283 AudioDiskstream::free_working_buffers();
285 /* tell everyone who is still standing that we're about to die */
288 /* tell everyone to drop references and delete objects as we go */
290 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
291 RegionFactory::delete_all_regions ();
293 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
295 /* reset these three references to special routes before we do the usual route delete thing */
298 _master_out.reset ();
299 _monitor_out.reset ();
302 RCUWriter<RouteList> writer (routes);
303 boost::shared_ptr<RouteList> r = writer.get_copy ();
305 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
306 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
307 (*i)->drop_references ();
311 /* writer goes out of scope and updates master */
315 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
316 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
317 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
318 i->second->drop_references ();
323 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
324 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
329 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
334 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
336 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
337 boost_debug_list_ptrs ();
342 Session::when_engine_running ()
344 string first_physical_output;
346 BootMessage (_("Set block size and sample rate"));
348 set_block_size (_engine.frames_per_cycle());
349 set_frame_rate (_engine.frame_rate());
351 BootMessage (_("Using configuration"));
353 boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
354 boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
356 Config->map_parameters (ff);
357 config.map_parameters (ft);
359 /* every time we reconnect, recompute worst case output latencies */
361 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
363 if (synced_to_jack()) {
364 _engine.transport_stop ();
367 if (config.get_jack_time_master()) {
368 _engine.transport_locate (_transport_frame);
376 _ltc_input.reset (new IO (*this, _("LTC In"), IO::Input));
377 _ltc_output.reset (new IO (*this, _("LTC Out"), IO::Output));
379 if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-In")) != 0) {
380 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
383 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
384 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
386 reconnect_ltc_input ();
389 if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-Out")) != 0) {
390 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
393 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
394 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
396 reconnect_ltc_output ();
399 /* fix up names of LTC ports because we don't want the normal
400 * IO style of NAME/TYPE-{in,out}N
403 _ltc_input->nth (0)->set_name (_("LTC-in"));
404 _ltc_output->nth (0)->set_name (_("LTC-out"));
406 _click_io.reset (new ClickIO (*this, "click"));
407 _click_gain.reset (new Amp (*this));
408 _click_gain->activate ();
410 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
412 /* existing state for Click */
415 if (Stateful::loading_state_version < 3000) {
416 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
418 const XMLNodeList& children (child->children());
419 XMLNodeList::const_iterator i = children.begin();
420 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
422 if (i != children.end()) {
423 c = _click_gain->set_state (**i, Stateful::loading_state_version);
429 _clicking = Config->get_clicking ();
433 error << _("could not setup Click I/O") << endmsg;
440 /* default state for Click: dual-mono to first 2 physical outputs */
443 _engine.get_physical_outputs (DataType::AUDIO, outs);
445 for (uint32_t physport = 0; physport < 2; ++physport) {
446 if (outs.size() > physport) {
447 if (_click_io->add_port (outs[physport], this)) {
448 // relax, even though its an error
453 if (_click_io->n_ports () > ChanCount::ZERO) {
454 _clicking = Config->get_clicking ();
459 catch (failed_constructor& err) {
460 error << _("cannot setup Click I/O") << endmsg;
463 BootMessage (_("Compute I/O Latencies"));
466 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
469 BootMessage (_("Set up standard connections"));
471 vector<string> inputs[DataType::num_types];
472 vector<string> outputs[DataType::num_types];
473 for (uint32_t i = 0; i < DataType::num_types; ++i) {
474 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
475 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
478 /* Create a set of Bundle objects that map
479 to the physical I/O currently available. We create both
480 mono and stereo bundles, so that the common cases of mono
481 and stereo tracks get bundles to put in their mixer strip
482 in / out menus. There may be a nicer way of achieving that;
483 it doesn't really scale that well to higher channel counts
486 /* mono output bundles */
488 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
490 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
492 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
493 c->add_channel (_("mono"), DataType::AUDIO);
494 c->set_port (0, outputs[DataType::AUDIO][np]);
499 /* stereo output bundles */
501 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
502 if (np + 1 < outputs[DataType::AUDIO].size()) {
504 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
505 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
506 c->add_channel (_("L"), DataType::AUDIO);
507 c->set_port (0, outputs[DataType::AUDIO][np]);
508 c->add_channel (_("R"), DataType::AUDIO);
509 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
515 /* mono input bundles */
517 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
519 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
521 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
522 c->add_channel (_("mono"), DataType::AUDIO);
523 c->set_port (0, inputs[DataType::AUDIO][np]);
528 /* stereo input bundles */
530 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
531 if (np + 1 < inputs[DataType::AUDIO].size()) {
533 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
535 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
536 c->add_channel (_("L"), DataType::AUDIO);
537 c->set_port (0, inputs[DataType::AUDIO][np]);
538 c->add_channel (_("R"), DataType::AUDIO);
539 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
545 /* MIDI input bundles */
547 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
548 string n = inputs[DataType::MIDI][np];
549 boost::erase_first (n, X_("alsa_pcm:"));
551 boost::shared_ptr<Bundle> c (new Bundle (n, false));
552 c->add_channel ("", DataType::MIDI);
553 c->set_port (0, inputs[DataType::MIDI][np]);
557 /* MIDI output bundles */
559 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
560 string n = outputs[DataType::MIDI][np];
561 boost::erase_first (n, X_("alsa_pcm:"));
563 boost::shared_ptr<Bundle> c (new Bundle (n, true));
564 c->add_channel ("", DataType::MIDI);
565 c->set_port (0, outputs[DataType::MIDI][np]);
569 BootMessage (_("Setup signal flow and plugins"));
571 /* Reset all panners */
573 Delivery::reset_panners ();
575 /* this will cause the CPM to instantiate any protocols that are in use
576 * (or mandatory), which will pass it this Session, and then call
577 * set_state() on each instantiated protocol to match stored state.
580 ControlProtocolManager::instance().set_session (this);
582 /* This must be done after the ControlProtocolManager set_session above,
583 as it will set states for ports which the ControlProtocolManager creates.
586 MIDI::Manager::instance()->set_port_states (Config->midi_port_states ());
588 /* And this must be done after the MIDI::Manager::set_port_states as
589 * it will try to make connections whose details are loaded by set_port_states.
594 /* Let control protocols know that we are now all connected, so they
595 * could start talking to surfaces if they want to.
598 ControlProtocolManager::instance().midi_connectivity_established ();
600 if (_is_new && !no_auto_connect()) {
601 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
602 auto_connect_master_bus ();
605 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
607 /* update latencies */
609 initialize_latencies ();
611 /* hook us up to the engine */
613 BootMessage (_("Connect to engine"));
614 _engine.set_session (this);
615 _engine.reset_timebase ();
619 Session::auto_connect_master_bus ()
621 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
625 /* if requested auto-connect the outputs to the first N physical ports.
628 uint32_t limit = _master_out->n_outputs().n_total();
629 vector<string> outputs[DataType::num_types];
631 for (uint32_t i = 0; i < DataType::num_types; ++i) {
632 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
635 for (uint32_t n = 0; n < limit; ++n) {
636 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
638 if (outputs[p->type()].size() > n) {
639 connect_to = outputs[p->type()][n];
642 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
643 if (_master_out->output()->connect (p, connect_to, this)) {
644 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
653 Session::remove_monitor_section ()
659 /* force reversion to Solo-In-Place */
660 Config->set_solo_control_is_listen_control (false);
663 /* Hold process lock while doing this so that we don't hear bits and
664 * pieces of audio as we work on each route.
667 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
669 /* Connect tracks to monitor section. Note that in an
670 existing session, the internal sends will already exist, but we want the
671 routes to notice that they connect to the control out specifically.
675 boost::shared_ptr<RouteList> r = routes.reader ();
676 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
678 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
680 if ((*x)->is_monitor()) {
682 } else if ((*x)->is_master()) {
685 (*x)->remove_aux_or_listen (_monitor_out);
690 remove_route (_monitor_out);
691 auto_connect_master_bus ();
695 Session::add_monitor_section ()
699 if (_monitor_out || !_master_out) {
703 boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
709 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
710 // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
713 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
714 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
715 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
719 add_routes (rl, false, false, false);
721 assert (_monitor_out);
723 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
724 are undefined, at best.
727 uint32_t limit = _monitor_out->n_inputs().n_audio();
731 /* connect the inputs to the master bus outputs. this
732 * represents a separate data feed from the internal sends from
733 * each route. as of jan 2011, it allows the monitor section to
734 * conditionally ignore either the internal sends or the normal
735 * input feed, but we should really find a better way to do
739 _master_out->output()->disconnect (this);
741 for (uint32_t n = 0; n < limit; ++n) {
742 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
743 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
746 string connect_to = o->name();
747 if (_monitor_out->input()->connect (p, connect_to, this)) {
748 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
756 /* if monitor section is not connected, connect it to physical outs
759 if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
761 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
763 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
766 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
768 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
769 Config->get_monitor_bus_preferred_bundle())
775 /* Monitor bus is audio only */
777 uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
778 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
779 vector<string> outputs[DataType::num_types];
781 for (uint32_t i = 0; i < DataType::num_types; ++i) {
782 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
788 for (uint32_t n = 0; n < limit; ++n) {
790 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
792 if (outputs[DataType::AUDIO].size() > (n % mod)) {
793 connect_to = outputs[DataType::AUDIO][n % mod];
796 if (!connect_to.empty()) {
797 if (_monitor_out->output()->connect (p, connect_to, this)) {
798 error << string_compose (
799 _("cannot connect control output %1 to %2"),
810 /* Hold process lock while doing this so that we don't hear bits and
811 * pieces of audio as we work on each route.
814 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
816 /* Connect tracks to monitor section. Note that in an
817 existing session, the internal sends will already exist, but we want the
818 routes to notice that they connect to the control out specifically.
822 boost::shared_ptr<RouteList> rls = routes.reader ();
824 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
826 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
828 if ((*x)->is_monitor()) {
830 } else if ((*x)->is_master()) {
833 (*x)->enable_monitor_send ();
839 Session::hookup_io ()
841 /* stop graph reordering notifications from
842 causing resorts, etc.
845 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
849 /* we delay creating the auditioner till now because
850 it makes its own connections to ports.
854 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
856 throw failed_constructor ();
858 a->use_new_diskstream ();
862 catch (failed_constructor& err) {
863 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
867 /* load bundles, which we may have postponed earlier on */
868 if (_bundle_xml_node) {
869 load_bundles (*_bundle_xml_node);
870 delete _bundle_xml_node;
873 /* Tell all IO objects to connect themselves together */
875 IO::enable_connecting ();
876 MIDI::JackMIDIPort::MakeConnections ();
878 /* Anyone who cares about input state, wake up and do something */
880 IOConnectionsComplete (); /* EMIT SIGNAL */
882 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
884 /* now handle the whole enchilada as if it was one
890 /* update the full solo state, which can't be
891 correctly determined on a per-route basis, but
892 needs the global overview that only the session
896 update_route_solo_state ();
900 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
902 boost::shared_ptr<Track> track = wp.lock ();
907 boost::shared_ptr<Playlist> playlist;
909 if ((playlist = track->playlist()) != 0) {
910 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
911 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
912 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
917 Session::record_enabling_legal () const
919 /* this used to be in here, but survey says.... we don't need to restrict it */
920 // if (record_status() == Recording) {
924 if (Config->get_all_safe()) {
931 Session::set_track_monitor_input_status (bool yn)
933 boost::shared_ptr<RouteList> rl = routes.reader ();
934 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
935 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
936 if (tr && tr->record_enabled ()) {
937 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
938 tr->request_jack_monitors_input (yn);
944 Session::auto_punch_start_changed (Location* location)
946 replace_event (SessionEvent::PunchIn, location->start());
948 if (get_record_enabled() && config.get_punch_in()) {
949 /* capture start has been changed, so save new pending state */
950 save_state ("", true);
955 Session::auto_punch_end_changed (Location* location)
957 framepos_t when_to_stop = location->end();
958 // when_to_stop += _worst_output_latency + _worst_input_latency;
959 replace_event (SessionEvent::PunchOut, when_to_stop);
963 Session::auto_punch_changed (Location* location)
965 framepos_t when_to_stop = location->end();
967 replace_event (SessionEvent::PunchIn, location->start());
968 //when_to_stop += _worst_output_latency + _worst_input_latency;
969 replace_event (SessionEvent::PunchOut, when_to_stop);
972 /** @param loc A loop location.
973 * @param pos Filled in with the start time of the required fade-out (in session frames).
974 * @param length Filled in with the length of the required fade-out.
977 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
979 pos = max (loc->start(), loc->end() - 64);
980 length = loc->end() - pos;
984 Session::auto_loop_changed (Location* location)
986 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
989 auto_loop_declick_range (location, dcp, dcl);
990 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
992 if (transport_rolling() && play_loop) {
995 // if (_transport_frame > location->end()) {
997 if (_transport_frame < location->start() || _transport_frame > location->end()) {
998 // relocate to beginning of loop
999 clear_events (SessionEvent::LocateRoll);
1001 request_locate (location->start(), true);
1004 else if (Config->get_seamless_loop() && !loop_changing) {
1006 // schedule a locate-roll to refill the diskstreams at the
1007 // previous loop end
1008 loop_changing = true;
1010 if (location->end() > last_loopend) {
1011 clear_events (SessionEvent::LocateRoll);
1012 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1019 last_loopend = location->end();
1023 Session::set_auto_punch_location (Location* location)
1027 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1028 punch_connections.drop_connections();
1029 existing->set_auto_punch (false, this);
1030 remove_event (existing->start(), SessionEvent::PunchIn);
1031 clear_events (SessionEvent::PunchOut);
1032 auto_punch_location_changed (0);
1037 if (location == 0) {
1041 if (location->end() <= location->start()) {
1042 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1046 punch_connections.drop_connections ();
1048 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
1049 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
1050 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
1052 location->set_auto_punch (true, this);
1054 auto_punch_changed (location);
1056 auto_punch_location_changed (location);
1060 Session::set_auto_loop_location (Location* location)
1064 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1065 loop_connections.drop_connections ();
1066 existing->set_auto_loop (false, this);
1067 remove_event (existing->end(), SessionEvent::AutoLoop);
1070 auto_loop_declick_range (existing, dcp, dcl);
1071 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1072 auto_loop_location_changed (0);
1077 if (location == 0) {
1081 if (location->end() <= location->start()) {
1082 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1086 last_loopend = location->end();
1088 loop_connections.drop_connections ();
1090 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1091 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1092 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1094 location->set_auto_loop (true, this);
1096 /* take care of our stuff first */
1098 auto_loop_changed (location);
1100 /* now tell everyone else */
1102 auto_loop_location_changed (location);
1106 Session::locations_added (Location *)
1112 Session::locations_changed ()
1114 _locations->apply (*this, &Session::handle_locations_changed);
1118 Session::handle_locations_changed (Locations::LocationList& locations)
1120 Locations::LocationList::iterator i;
1122 bool set_loop = false;
1123 bool set_punch = false;
1125 for (i = locations.begin(); i != locations.end(); ++i) {
1129 if (location->is_auto_punch()) {
1130 set_auto_punch_location (location);
1133 if (location->is_auto_loop()) {
1134 set_auto_loop_location (location);
1138 if (location->is_session_range()) {
1139 _session_range_location = location;
1144 set_auto_loop_location (0);
1147 set_auto_punch_location (0);
1154 Session::enable_record ()
1156 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1157 /* no recording at anything except normal speed */
1162 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1164 if (rs == Recording) {
1168 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1170 _last_record_location = _transport_frame;
1171 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1173 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1174 set_track_monitor_input_status (true);
1177 RecordStateChanged ();
1184 Session::disable_record (bool rt_context, bool force)
1188 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1190 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1191 g_atomic_int_set (&_record_status, Disabled);
1192 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1194 if (rs == Recording) {
1195 g_atomic_int_set (&_record_status, Enabled);
1199 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1200 set_track_monitor_input_status (false);
1203 RecordStateChanged (); /* emit signal */
1206 remove_pending_capture_state ();
1212 Session::step_back_from_record ()
1214 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1216 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1217 set_track_monitor_input_status (false);
1220 RecordStateChanged (); /* emit signal */
1225 Session::maybe_enable_record ()
1227 if (_step_editors > 0) {
1231 g_atomic_int_set (&_record_status, Enabled);
1233 /* This function is currently called from somewhere other than an RT thread.
1234 This save_state() call therefore doesn't impact anything. Doing it here
1235 means that we save pending state of which sources the next record will use,
1236 which gives us some chance of recovering from a crash during the record.
1239 save_state ("", true);
1241 if (_transport_speed) {
1242 if (!config.get_punch_in()) {
1246 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1247 RecordStateChanged (); /* EMIT SIGNAL */
1254 Session::audible_frame () const
1260 /* the first of these two possible settings for "offset"
1261 mean that the audible frame is stationary until
1262 audio emerges from the latency compensation
1265 the second means that the audible frame is stationary
1266 until audio would emerge from a physical port
1267 in the absence of any plugin latency compensation
1270 offset = worst_playback_latency ();
1272 if (offset > current_block_size) {
1273 offset -= current_block_size;
1275 /* XXX is this correct? if we have no external
1276 physical connections and everything is internal
1277 then surely this is zero? still, how
1278 likely is that anyway?
1280 offset = current_block_size;
1283 if (synced_to_jack()) {
1284 tf = _engine.transport_frame();
1286 tf = _transport_frame;
1291 if (!non_realtime_work_pending()) {
1295 /* Check to see if we have passed the first guaranteed
1296 audible frame past our last start position. if not,
1297 return that last start point because in terms
1298 of audible frames, we have not moved yet.
1300 `Start position' in this context means the time we last
1301 either started, located, or changed transport direction.
1304 if (_transport_speed > 0.0f) {
1306 if (!play_loop || !have_looped) {
1307 if (tf < _last_roll_or_reversal_location + offset) {
1308 return _last_roll_or_reversal_location;
1316 } else if (_transport_speed < 0.0f) {
1318 /* XXX wot? no backward looping? */
1320 if (tf > _last_roll_or_reversal_location - offset) {
1321 return _last_roll_or_reversal_location;
1333 Session::set_frame_rate (framecnt_t frames_per_second)
1335 /** \fn void Session::set_frame_size(framecnt_t)
1336 the AudioEngine object that calls this guarantees
1337 that it will not be called while we are also in
1338 ::process(). Its fine to do things that block
1342 _base_frame_rate = frames_per_second;
1348 // XXX we need some equivalent to this, somehow
1349 // SndFileSource::setup_standard_crossfades (frames_per_second);
1353 /* XXX need to reset/reinstantiate all LADSPA plugins */
1357 Session::set_block_size (pframes_t nframes)
1359 /* the AudioEngine guarantees
1360 that it will not be called while we are also in
1361 ::process(). It is therefore fine to do things that block
1366 current_block_size = nframes;
1370 boost::shared_ptr<RouteList> r = routes.reader ();
1372 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1373 (*i)->set_block_size (nframes);
1376 boost::shared_ptr<RouteList> rl = routes.reader ();
1377 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1378 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1380 tr->set_block_size (nframes);
1384 set_worst_io_latencies ();
1390 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1392 boost::shared_ptr<Route> r2;
1394 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1395 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1399 /* make a copy of the existing list of routes that feed r1 */
1401 Route::FedBy existing (r1->fed_by());
1403 /* for each route that feeds r1, recurse, marking it as feeding
1407 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1408 if (!(r2 = i->r.lock ())) {
1409 /* (*i) went away, ignore it */
1413 /* r2 is a route that feeds r1 which somehow feeds base. mark
1414 base as being fed by r2
1417 rbase->add_fed_by (r2, i->sends_only);
1421 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1425 if (r1->feeds (r2) && r2->feeds (r1)) {
1429 /* now recurse, so that we can mark base as being fed by
1430 all routes that feed r2
1433 trace_terminal (r2, rbase);
1440 Session::resort_routes ()
1442 /* don't do anything here with signals emitted
1443 by Routes during initial setup or while we
1444 are being destroyed.
1447 if (_state_of_the_state & (InitialConnecting | Deletion)) {
1452 RCUWriter<RouteList> writer (routes);
1453 boost::shared_ptr<RouteList> r = writer.get_copy ();
1454 resort_routes_using (r);
1455 /* writer goes out of scope and forces update */
1459 boost::shared_ptr<RouteList> rl = routes.reader ();
1460 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1461 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1463 const Route::FedBy& fb ((*i)->fed_by());
1465 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1466 boost::shared_ptr<Route> sf = f->r.lock();
1468 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1476 /** This is called whenever we need to rebuild the graph of how we will process
1478 * @param r List of routes, in any order.
1482 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1484 /* We are going to build a directed graph of our routes;
1485 this is where the edges of that graph are put.
1490 /* Go through all routes doing two things:
1492 * 1. Collect the edges of the route graph. Each of these edges
1493 * is a pair of routes, one of which directly feeds the other
1494 * either by a JACK connection or by an internal send.
1496 * 2. Begin the process of making routes aware of which other
1497 * routes directly or indirectly feed them. This information
1498 * is used by the solo code.
1501 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1503 /* Clear out the route's list of direct or indirect feeds */
1504 (*i)->clear_fed_by ();
1506 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1508 bool via_sends_only;
1510 /* See if this *j feeds *i according to the current state of the JACK
1511 connections and internal sends.
1513 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1514 /* add the edge to the graph (part #1) */
1515 edges.add (*j, *i, via_sends_only);
1516 /* tell the route (for part #2) */
1517 (*i)->add_fed_by (*j, via_sends_only);
1522 /* Attempt a topological sort of the route graph */
1523 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1525 if (Config->get_ignore_feedback_loops() || sorted_routes) {
1526 /* We got a satisfactory topological sort, so there is no feedback;
1529 Note: the process graph rechain does not require a
1530 topologically-sorted list, but hey ho.
1532 if (_process_graph) {
1533 _process_graph->rechain (sorted_routes, edges);
1536 _current_route_graph = edges;
1538 /* Complete the building of the routes' lists of what directly
1539 or indirectly feeds them.
1541 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1542 trace_terminal (*i, *i);
1545 *r = *sorted_routes;
1548 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1549 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1550 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1551 (*i)->name(), (*i)->order_key (MixerSort)));
1555 SuccessfulGraphSort (); /* EMIT SIGNAL */
1558 if (!sorted_routes) {
1559 /* The topological sort failed, so we have a problem. Tell everyone
1560 and stick to the old graph; this will continue to be processed, so
1561 until the feedback is fixed, what is played back will not quite
1562 reflect what is actually connected. Note also that we do not
1563 do trace_terminal here, as it would fail due to an endless recursion,
1564 so the solo code will think that everything is still connected
1568 FeedbackDetected (); /* EMIT SIGNAL */
1573 /** Find a route name starting with \a base, maybe followed by the
1574 * lowest \a id. \a id will always be added if \a definitely_add_number
1575 * is true on entry; otherwise it will only be added if required
1576 * to make the name unique.
1578 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1579 * The available route name with the lowest ID will be used, and \a id
1580 * will be set to the ID.
1582 * \return false if a route name could not be found, and \a track_name
1583 * and \a id do not reflect a free route name.
1586 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1588 if (!definitely_add_number && route_by_name (base) == 0) {
1589 /* juse use the base */
1590 snprintf (name, name_len, "%s", base.c_str());
1595 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1597 if (route_by_name (name) == 0) {
1603 } while (id < (UINT_MAX-1));
1608 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1610 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1612 in = ChanCount::ZERO;
1613 out = ChanCount::ZERO;
1615 boost::shared_ptr<RouteList> r = routes.reader ();
1617 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1618 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1619 if (tr && !tr->is_auditioner()) {
1620 in += tr->n_inputs();
1621 out += tr->n_outputs();
1626 /** Caller must not hold process lock
1627 * @param name_template string to use for the start of the name, or "" to use "MIDI".
1628 * @param instrument plugin info for the instrument to insert pre-fader, if any
1630 list<boost::shared_ptr<MidiTrack> >
1631 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1632 TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1634 char track_name[32];
1635 uint32_t track_id = 0;
1637 RouteList new_routes;
1638 list<boost::shared_ptr<MidiTrack> > ret;
1640 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1643 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1644 error << "cannot find name for new midi track" << endmsg;
1648 boost::shared_ptr<MidiTrack> track;
1651 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1653 if (track->init ()) {
1657 track->use_new_diskstream();
1659 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1660 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1663 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1664 if (track->input()->ensure_io (input, false, this)) {
1665 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1669 if (track->output()->ensure_io (output, false, this)) {
1670 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1675 track->non_realtime_input_change();
1678 route_group->add (track);
1681 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1683 if (Config->get_remote_model() == UserOrdered) {
1684 track->set_remote_control_id (next_control_id());
1687 new_routes.push_back (track);
1688 ret.push_back (track);
1691 catch (failed_constructor &err) {
1692 error << _("Session: could not create new midi track.") << endmsg;
1696 catch (AudioEngine::PortRegistrationFailure& pfe) {
1698 error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
1706 if (!new_routes.empty()) {
1707 add_routes (new_routes, true, true, true);
1710 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1711 PluginPtr plugin = instrument->load (*this);
1712 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1713 (*r)->add_processor (p, PreFader);
1723 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1725 boost::shared_ptr<Route> midi_track (wmt.lock());
1731 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1733 if (change.after.n_audio() <= change.before.n_audio()) {
1737 /* new audio ports: make sure the audio goes somewhere useful,
1738 unless the user has no-auto-connect selected.
1740 The existing ChanCounts don't matter for this call as they are only
1741 to do with matching input and output indices, and we are only changing
1747 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1751 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1752 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1753 * @param output_start As \a input_start, but for outputs.
1756 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1757 bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1759 if (!IO::connecting_legal) {
1763 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1769 /* If both inputs and outputs are auto-connected to physical ports,
1770 use the max of input and output offsets to ensure auto-connected
1771 port numbers always match up (e.g. the first audio input and the
1772 first audio output of the route will have the same physical
1773 port number). Otherwise just use the lowest input or output
1777 DEBUG_TRACE (DEBUG::Graph,
1778 string_compose("Auto-connect: existing in = %1 out = %2\n",
1779 existing_inputs, existing_outputs));
1781 const bool in_out_physical =
1782 (Config->get_input_auto_connect() & AutoConnectPhysical)
1783 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1786 const ChanCount in_offset = in_out_physical
1787 ? ChanCount::max(existing_inputs, existing_outputs)
1790 const ChanCount out_offset = in_out_physical
1791 ? ChanCount::max(existing_inputs, existing_outputs)
1794 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1795 vector<string> physinputs;
1796 vector<string> physoutputs;
1798 _engine.get_physical_outputs (*t, physoutputs);
1799 _engine.get_physical_inputs (*t, physinputs);
1801 if (!physinputs.empty() && connect_inputs) {
1802 uint32_t nphysical_in = physinputs.size();
1804 DEBUG_TRACE (DEBUG::Graph,
1805 string_compose("There are %1 physical inputs of type %2\n",
1808 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1811 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1812 DEBUG_TRACE (DEBUG::Graph,
1813 string_compose("Get index %1 + %2 % %3 = %4\n",
1814 in_offset.get(*t), i, nphysical_in,
1815 (in_offset.get(*t) + i) % nphysical_in));
1816 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1819 DEBUG_TRACE (DEBUG::Graph,
1820 string_compose("Connect route %1 IN to %2\n",
1821 route->name(), port));
1823 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1827 ChanCount one_added (*t, 1);
1828 existing_inputs += one_added;
1832 if (!physoutputs.empty()) {
1833 uint32_t nphysical_out = physoutputs.size();
1834 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1837 if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
1838 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1839 } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
1840 /* master bus is audio only */
1841 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1842 port = _master_out->input()->ports().port(*t,
1843 i % _master_out->input()->n_ports().get(*t))->name();
1847 DEBUG_TRACE (DEBUG::Graph,
1848 string_compose("Connect route %1 OUT to %2\n",
1849 route->name(), port));
1851 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
1855 ChanCount one_added (*t, 1);
1856 existing_outputs += one_added;
1862 /** Caller must not hold process lock
1863 * @param name_template string to use for the start of the name, or "" to use "Audio".
1865 list< boost::shared_ptr<AudioTrack> >
1866 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
1867 uint32_t how_many, string name_template)
1869 char track_name[32];
1870 uint32_t track_id = 0;
1872 RouteList new_routes;
1873 list<boost::shared_ptr<AudioTrack> > ret;
1875 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
1878 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1879 error << "cannot find name for new audio track" << endmsg;
1883 boost::shared_ptr<AudioTrack> track;
1886 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
1888 if (track->init ()) {
1892 track->use_new_diskstream();
1894 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1895 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1898 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1900 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1901 error << string_compose (
1902 _("cannot configure %1 in/%2 out configuration for new audio track"),
1903 input_channels, output_channels)
1908 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1909 error << string_compose (
1910 _("cannot configure %1 in/%2 out configuration for new audio track"),
1911 input_channels, output_channels)
1918 route_group->add (track);
1921 track->non_realtime_input_change();
1923 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1924 if (Config->get_remote_model() == UserOrdered) {
1925 track->set_remote_control_id (next_control_id());
1928 new_routes.push_back (track);
1929 ret.push_back (track);
1932 catch (failed_constructor &err) {
1933 error << _("Session: could not create new audio track.") << endmsg;
1937 catch (AudioEngine::PortRegistrationFailure& pfe) {
1939 error << pfe.what() << endmsg;
1947 if (!new_routes.empty()) {
1948 add_routes (new_routes, true, true, true);
1954 /** Caller must not hold process lock.
1955 * @param name_template string to use for the start of the name, or "" to use "Bus".
1958 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
1961 uint32_t bus_id = 0;
1965 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
1968 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
1969 error << "cannot find name for new audio bus" << endmsg;
1974 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
1980 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1981 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
1984 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1986 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1987 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1988 input_channels, output_channels)
1994 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1995 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1996 input_channels, output_channels)
2003 route_group->add (bus);
2005 if (Config->get_remote_model() == UserOrdered) {
2006 bus->set_remote_control_id (next_control_id());
2009 bus->add_internal_return ();
2011 ret.push_back (bus);
2017 catch (failed_constructor &err) {
2018 error << _("Session: could not create new audio route.") << endmsg;
2022 catch (AudioEngine::PortRegistrationFailure& pfe) {
2023 error << pfe.what() << endmsg;
2033 add_routes (ret, false, true, true); // autoconnect outputs only
2041 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2044 uint32_t control_id;
2046 uint32_t number = 0;
2047 const uint32_t being_added = how_many;
2049 if (!tree.read (template_path.c_str())) {
2053 XMLNode* node = tree.root();
2055 IO::disable_connecting ();
2057 control_id = next_control_id ();
2061 XMLNode node_copy (*node);
2063 /* Remove IDs of everything so that new ones are used */
2064 node_copy.remove_property_recursively (X_("id"));
2069 if (!name_base.empty()) {
2071 /* if we're adding more than one routes, force
2072 * all the names of the new routes to be
2073 * numbered, via the final parameter.
2076 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2077 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2083 string const route_name = node_copy.property(X_("name"))->value ();
2085 /* generate a new name by adding a number to the end of the template name */
2086 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2087 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2092 /* set this name in the XML description that we are about to use */
2093 Route::set_name_in_state (node_copy, name);
2095 /* trim bitslots from listen sends so that new ones are used */
2096 XMLNodeList children = node_copy.children ();
2097 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2098 if ((*i)->name() == X_("Processor")) {
2099 XMLProperty* role = (*i)->property (X_("role"));
2100 if (role && role->value() == X_("Listen")) {
2101 (*i)->remove_property (X_("bitslot"));
2106 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2109 error << _("Session: cannot create track/bus from template description") << endmsg;
2113 if (boost::dynamic_pointer_cast<Track>(route)) {
2114 /* force input/output change signals so that the new diskstream
2115 picks up the configuration of the route. During session
2116 loading this normally happens in a different way.
2119 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2121 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2122 change.after = route->input()->n_ports();
2123 route->input()->changed (change, this);
2124 change.after = route->output()->n_ports();
2125 route->output()->changed (change, this);
2128 route->set_remote_control_id (control_id);
2131 ret.push_back (route);
2134 catch (failed_constructor &err) {
2135 error << _("Session: could not create new route from template") << endmsg;
2139 catch (AudioEngine::PortRegistrationFailure& pfe) {
2140 error << pfe.what() << endmsg;
2149 add_routes (ret, true, true, true);
2150 IO::enable_connecting ();
2157 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2160 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2161 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2164 error << _("Adding new tracks/busses failed") << endmsg;
2169 update_latency (true);
2170 update_latency (false);
2175 save_state (_current_snapshot_name);
2178 RouteAdded (new_routes); /* EMIT SIGNAL */
2182 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2184 ChanCount existing_inputs;
2185 ChanCount existing_outputs;
2186 uint32_t order = next_control_id();
2188 count_existing_track_channels (existing_inputs, existing_outputs);
2191 RCUWriter<RouteList> writer (routes);
2192 boost::shared_ptr<RouteList> r = writer.get_copy ();
2193 r->insert (r->end(), new_routes.begin(), new_routes.end());
2195 /* if there is no control out and we're not in the middle of loading,
2196 resort the graph here. if there is a control out, we will resort
2197 toward the end of this method. if we are in the middle of loading,
2198 we will resort when done.
2201 if (!_monitor_out && IO::connecting_legal) {
2202 resort_routes_using (r);
2206 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2208 boost::weak_ptr<Route> wpr (*x);
2209 boost::shared_ptr<Route> r (*x);
2211 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2212 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2213 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2214 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2215 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2216 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2218 if (r->is_master()) {
2222 if (r->is_monitor()) {
2226 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2228 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2229 track_playlist_changed (boost::weak_ptr<Track> (tr));
2230 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2232 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2234 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2235 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2240 if (input_auto_connect || output_auto_connect) {
2241 auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2244 /* order keys are a GUI responsibility but we need to set up
2245 reasonable defaults because they also affect the remote control
2246 ID in most situations.
2249 if (!r->has_order_key (EditorSort)) {
2250 if (r->is_auditioner()) {
2251 /* use an arbitrarily high value */
2252 r->set_order_key (EditorSort, UINT_MAX);
2253 r->set_order_key (MixerSort, UINT_MAX);
2255 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2256 r->set_order_key (EditorSort, order);
2257 r->set_order_key (MixerSort, order);
2265 if (_monitor_out && IO::connecting_legal) {
2266 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2268 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2269 if ((*x)->is_monitor()) {
2271 } else if ((*x)->is_master()) {
2274 (*x)->enable_monitor_send ();
2281 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2283 boost::shared_ptr<RouteList> r = routes.reader ();
2284 boost::shared_ptr<Send> s;
2286 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2287 if ((s = (*i)->internal_send_for (dest)) != 0) {
2288 s->amp()->gain_control()->set_value (0.0);
2294 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2296 boost::shared_ptr<RouteList> r = routes.reader ();
2297 boost::shared_ptr<Send> s;
2299 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2300 if ((s = (*i)->internal_send_for (dest)) != 0) {
2301 s->amp()->gain_control()->set_value (1.0);
2307 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2309 boost::shared_ptr<RouteList> r = routes.reader ();
2310 boost::shared_ptr<Send> s;
2312 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2313 if ((s = (*i)->internal_send_for (dest)) != 0) {
2314 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2319 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2321 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2323 boost::shared_ptr<RouteList> r = routes.reader ();
2324 boost::shared_ptr<RouteList> t (new RouteList);
2326 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2327 /* no MIDI sends because there are no MIDI busses yet */
2328 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2333 add_internal_sends (dest, p, t);
2337 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2339 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2340 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2345 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2347 add_internal_send (dest, sender->before_processor_for_index (index), sender);
2351 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2353 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2357 if (!dest->internal_return()) {
2358 dest->add_internal_return ();
2361 sender->add_aux_send (dest, before);
2367 Session::remove_route (boost::shared_ptr<Route> route)
2369 if (route == _master_out) {
2373 route->set_solo (false, this);
2376 RCUWriter<RouteList> writer (routes);
2377 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2381 /* deleting the master out seems like a dumb
2382 idea, but its more of a UI policy issue
2386 if (route == _master_out) {
2387 _master_out = boost::shared_ptr<Route> ();
2390 if (route == _monitor_out) {
2391 _monitor_out.reset ();
2394 /* writer goes out of scope, forces route list update */
2397 update_route_solo_state ();
2399 // We need to disconnect the route's inputs and outputs
2401 route->input()->disconnect (0);
2402 route->output()->disconnect (0);
2404 /* if the route had internal sends sending to it, remove them */
2405 if (route->internal_return()) {
2407 boost::shared_ptr<RouteList> r = routes.reader ();
2408 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2409 boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2411 (*i)->remove_processor (s);
2416 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2417 if (mt && mt->step_editing()) {
2418 if (_step_editors > 0) {
2423 update_latency_compensation ();
2426 /* Re-sort routes to remove the graph's current references to the one that is
2427 * going away, then flush old references out of the graph.
2431 if (_process_graph) {
2432 _process_graph->clear_other_chain ();
2435 /* get rid of it from the dead wood collection in the route list manager */
2437 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2441 /* try to cause everyone to drop their references */
2443 route->drop_references ();
2445 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2447 /* save the new state of the world */
2449 if (save_state (_current_snapshot_name)) {
2450 save_history (_current_snapshot_name);
2455 Session::route_mute_changed (void* /*src*/)
2461 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2463 boost::shared_ptr<Route> route = wpr.lock();
2465 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2469 if (route->listening_via_monitor ()) {
2471 if (Config->get_exclusive_solo()) {
2472 /* new listen: disable all other listen */
2473 boost::shared_ptr<RouteList> r = routes.reader ();
2474 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2475 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
2478 (*i)->set_listen (false, this);
2484 } else if (_listen_cnt > 0) {
2489 update_route_solo_state ();
2492 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2494 boost::shared_ptr<Route> route = wpr.lock ();
2497 /* should not happen */
2498 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2502 bool send_changed = false;
2504 if (route->solo_isolated()) {
2505 if (_solo_isolated_cnt == 0) {
2506 send_changed = true;
2508 _solo_isolated_cnt++;
2509 } else if (_solo_isolated_cnt > 0) {
2510 _solo_isolated_cnt--;
2511 if (_solo_isolated_cnt == 0) {
2512 send_changed = true;
2517 IsolatedChanged (); /* EMIT SIGNAL */
2522 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2524 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2526 if (!self_solo_change) {
2527 // session doesn't care about changes to soloed-by-others
2531 if (solo_update_disabled) {
2533 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2537 boost::shared_ptr<Route> route = wpr.lock ();
2540 boost::shared_ptr<RouteList> r = routes.reader ();
2543 if (route->self_soloed()) {
2549 RouteGroup* rg = route->route_group ();
2550 bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2552 if (delta == 1 && Config->get_exclusive_solo()) {
2554 /* new solo: disable all other solos, but not the group if its solo-enabled */
2556 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2557 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2558 (leave_group_alone && ((*i)->route_group() == rg))) {
2561 (*i)->set_solo (false, this);
2565 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2567 solo_update_disabled = true;
2569 RouteList uninvolved;
2571 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2573 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2574 bool via_sends_only;
2575 bool in_signal_flow;
2577 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2578 (leave_group_alone && ((*i)->route_group() == rg))) {
2582 in_signal_flow = false;
2584 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2586 if ((*i)->feeds (route, &via_sends_only)) {
2587 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2588 if (!via_sends_only) {
2589 if (!route->soloed_by_others_upstream()) {
2590 (*i)->mod_solo_by_others_downstream (delta);
2593 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2595 in_signal_flow = true;
2597 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2600 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2602 if (route->feeds (*i, &via_sends_only)) {
2603 /* propagate solo upstream only if routing other than
2604 sends is involved, but do consider the other route
2605 (*i) to be part of the signal flow even if only
2608 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2612 route->soloed_by_others_downstream(),
2613 route->soloed_by_others_upstream()));
2614 if (!via_sends_only) {
2615 if (!route->soloed_by_others_downstream()) {
2616 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2617 (*i)->mod_solo_by_others_upstream (delta);
2619 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2622 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2624 in_signal_flow = true;
2626 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2629 if (!in_signal_flow) {
2630 uninvolved.push_back (*i);
2634 solo_update_disabled = false;
2635 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2637 update_route_solo_state (r);
2639 /* now notify that the mute state of the routes not involved in the signal
2640 pathway of the just-solo-changed route may have altered.
2643 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2644 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2645 (*i)->mute_changed (this);
2648 SoloChanged (); /* EMIT SIGNAL */
2653 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2655 /* now figure out if anything that matters is soloed (or is "listening")*/
2657 bool something_soloed = false;
2658 uint32_t listeners = 0;
2659 uint32_t isolated = 0;
2662 r = routes.reader();
2665 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2666 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
2667 something_soloed = true;
2670 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
2671 if (Config->get_solo_control_is_listen_control()) {
2674 (*i)->set_listen (false, this);
2678 if ((*i)->solo_isolated()) {
2683 if (something_soloed != _non_soloed_outs_muted) {
2684 _non_soloed_outs_muted = something_soloed;
2685 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2688 _listen_cnt = listeners;
2690 if (isolated != _solo_isolated_cnt) {
2691 _solo_isolated_cnt = isolated;
2692 IsolatedChanged (); /* EMIT SIGNAL */
2695 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2696 something_soloed, listeners, isolated));
2699 boost::shared_ptr<RouteList>
2700 Session::get_routes_with_internal_returns() const
2702 boost::shared_ptr<RouteList> r = routes.reader ();
2703 boost::shared_ptr<RouteList> rl (new RouteList);
2705 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2706 if ((*i)->internal_return ()) {
2714 Session::io_name_is_legal (const std::string& name)
2716 boost::shared_ptr<RouteList> r = routes.reader ();
2718 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2719 if ((*i)->name() == name) {
2723 if ((*i)->has_io_processor_named (name)) {
2732 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2735 vector<string> connections;
2737 /* if we are passed only a single route and we're not told to turn
2738 * others off, then just do the simple thing.
2741 if (flip_others == false && rl->size() == 1) {
2742 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2744 mt->set_input_active (onoff);
2749 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2751 PortSet& ps ((*rt)->input()->ports());
2753 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2754 p->get_connections (connections);
2757 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2758 routes_using_input_from (*s, rl2);
2761 /* scan all relevant routes to see if others are on or off */
2763 bool others_are_already_on = false;
2765 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2767 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2773 if ((*r) != (*rt)) {
2774 if (mt->input_active()) {
2775 others_are_already_on = true;
2778 /* this one needs changing */
2779 mt->set_input_active (onoff);
2785 /* globally reverse other routes */
2787 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2788 if ((*r) != (*rt)) {
2789 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2791 mt->set_input_active (!others_are_already_on);
2800 Session::routes_using_input_from (const string& str, RouteList& rl)
2802 boost::shared_ptr<RouteList> r = routes.reader();
2804 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2805 if ((*i)->input()->connected_to (str)) {
2811 boost::shared_ptr<Route>
2812 Session::route_by_name (string name)
2814 boost::shared_ptr<RouteList> r = routes.reader ();
2816 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2817 if ((*i)->name() == name) {
2822 return boost::shared_ptr<Route> ((Route*) 0);
2825 boost::shared_ptr<Route>
2826 Session::route_by_id (PBD::ID id)
2828 boost::shared_ptr<RouteList> r = routes.reader ();
2830 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2831 if ((*i)->id() == id) {
2836 return boost::shared_ptr<Route> ((Route*) 0);
2839 boost::shared_ptr<Track>
2840 Session::track_by_diskstream_id (PBD::ID id)
2842 boost::shared_ptr<RouteList> r = routes.reader ();
2844 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2845 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
2846 if (t && t->using_diskstream_id (id)) {
2851 return boost::shared_ptr<Track> ();
2854 boost::shared_ptr<Route>
2855 Session::route_by_remote_id (uint32_t id)
2857 boost::shared_ptr<RouteList> r = routes.reader ();
2859 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2860 if ((*i)->remote_control_id() == id) {
2865 return boost::shared_ptr<Route> ((Route*) 0);
2869 Session::playlist_region_added (boost::weak_ptr<Region> w)
2871 boost::shared_ptr<Region> r = w.lock ();
2876 /* These are the operations that are currently in progress... */
2877 list<GQuark> curr = _current_trans_quarks;
2880 /* ...and these are the operations during which we want to update
2881 the session range location markers.
2884 ops.push_back (Operations::capture);
2885 ops.push_back (Operations::paste);
2886 ops.push_back (Operations::duplicate_region);
2887 ops.push_back (Operations::insert_file);
2888 ops.push_back (Operations::insert_region);
2889 ops.push_back (Operations::drag_region_brush);
2890 ops.push_back (Operations::region_drag);
2891 ops.push_back (Operations::selection_grab);
2892 ops.push_back (Operations::region_fill);
2893 ops.push_back (Operations::fill_selection);
2894 ops.push_back (Operations::create_region);
2895 ops.push_back (Operations::region_copy);
2896 ops.push_back (Operations::fixed_time_region_copy);
2899 /* See if any of the current operations match the ones that we want */
2901 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2903 /* If so, update the session range markers */
2905 maybe_update_session_range (r->position (), r->last_frame ());
2909 /** Update the session range markers if a is before the current start or
2910 * b is after the current end.
2913 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2915 if (_state_of_the_state & Loading) {
2919 if (_session_range_location == 0) {
2921 add_session_range_location (a, b);
2925 if (a < _session_range_location->start()) {
2926 _session_range_location->set_start (a);
2929 if (b > _session_range_location->end()) {
2930 _session_range_location->set_end (b);
2936 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2938 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2939 maybe_update_session_range (i->to, i->to + i->length);
2944 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2946 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2947 maybe_update_session_range (i->from, i->to);
2951 /* Region management */
2953 boost::shared_ptr<Region>
2954 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2956 const RegionFactory::RegionMap& regions (RegionFactory::regions());
2957 RegionFactory::RegionMap::const_iterator i;
2958 boost::shared_ptr<Region> region;
2960 Glib::Threads::Mutex::Lock lm (region_lock);
2962 for (i = regions.begin(); i != regions.end(); ++i) {
2966 if (region->whole_file()) {
2968 if (child->source_equivalent (region)) {
2974 return boost::shared_ptr<Region> ();
2978 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2980 set<boost::shared_ptr<Region> > relevant_regions;
2982 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2983 RegionFactory::get_regions_using_source (*s, relevant_regions);
2986 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2987 set<boost::shared_ptr<Region> >::iterator tmp;
2992 playlists->destroy_region (*r);
2993 RegionFactory::map_remove (*r);
2995 (*r)->drop_sources ();
2996 (*r)->drop_references ();
2998 relevant_regions.erase (r);
3003 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3006 Glib::Threads::Mutex::Lock ls (source_lock);
3007 /* remove from the main source list */
3008 sources.erase ((*s)->id());
3011 (*s)->mark_for_remove ();
3012 (*s)->drop_references ();
3021 Session::remove_last_capture ()
3023 list<boost::shared_ptr<Source> > srcs;
3025 boost::shared_ptr<RouteList> rl = routes.reader ();
3026 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3027 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3032 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3035 srcs.insert (srcs.end(), l.begin(), l.end());
3040 destroy_sources (srcs);
3042 save_state (_current_snapshot_name);
3047 /* Source Management */
3050 Session::add_source (boost::shared_ptr<Source> source)
3052 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3053 pair<SourceMap::iterator,bool> result;
3055 entry.first = source->id();
3056 entry.second = source;
3059 Glib::Threads::Mutex::Lock lm (source_lock);
3060 result = sources.insert (entry);
3063 if (result.second) {
3065 /* yay, new source */
3067 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3070 if (!fs->within_session()) {
3071 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3077 boost::shared_ptr<AudioFileSource> afs;
3079 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3080 if (Config->get_auto_analyse_audio()) {
3081 Analyser::queue_source_for_analysis (source, false);
3085 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3090 Session::remove_source (boost::weak_ptr<Source> src)
3092 if (_state_of_the_state & Deletion) {
3096 SourceMap::iterator i;
3097 boost::shared_ptr<Source> source = src.lock();
3104 Glib::Threads::Mutex::Lock lm (source_lock);
3106 if ((i = sources.find (source->id())) != sources.end()) {
3111 if (!(_state_of_the_state & InCleanup)) {
3113 /* save state so we don't end up with a session file
3114 referring to non-existent sources.
3117 save_state (_current_snapshot_name);
3121 boost::shared_ptr<Source>
3122 Session::source_by_id (const PBD::ID& id)
3124 Glib::Threads::Mutex::Lock lm (source_lock);
3125 SourceMap::iterator i;
3126 boost::shared_ptr<Source> source;
3128 if ((i = sources.find (id)) != sources.end()) {
3135 boost::shared_ptr<Source>
3136 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3138 Glib::Threads::Mutex::Lock lm (source_lock);
3140 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3141 boost::shared_ptr<AudioFileSource> afs
3142 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3144 if (afs && afs->path() == path && chn == afs->channel()) {
3148 return boost::shared_ptr<Source>();
3152 Session::count_sources_by_origin (const string& path)
3155 Glib::Threads::Mutex::Lock lm (source_lock);
3157 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3158 boost::shared_ptr<FileSource> fs
3159 = boost::dynamic_pointer_cast<FileSource>(i->second);
3161 if (fs && fs->origin() == path) {
3171 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3174 string old_basename = PBD::basename_nosuffix (oldname);
3175 string new_legalized = legalize_for_path (newname);
3177 /* note: we know (or assume) the old path is already valid */
3181 /* destructive file sources have a name of the form:
3183 /path/to/Tnnnn-NAME(%[LR])?.wav
3185 the task here is to replace NAME with the new name.
3190 string::size_type dash;
3192 dir = Glib::path_get_dirname (path);
3193 path = Glib::path_get_basename (path);
3195 /* '-' is not a legal character for the NAME part of the path */
3197 if ((dash = path.find_last_of ('-')) == string::npos) {
3201 prefix = path.substr (0, dash);
3205 path += new_legalized;
3206 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3207 path = Glib::build_filename (dir, path);
3211 /* non-destructive file sources have a name of the form:
3213 /path/to/NAME-nnnnn(%[LR])?.ext
3215 the task here is to replace NAME with the new name.
3220 string::size_type dash;
3221 string::size_type postfix;
3223 dir = Glib::path_get_dirname (path);
3224 path = Glib::path_get_basename (path);
3226 /* '-' is not a legal character for the NAME part of the path */
3228 if ((dash = path.find_last_of ('-')) == string::npos) {
3232 suffix = path.substr (dash+1);
3234 // Suffix is now everything after the dash. Now we need to eliminate
3235 // the nnnnn part, which is done by either finding a '%' or a '.'
3237 postfix = suffix.find_last_of ("%");
3238 if (postfix == string::npos) {
3239 postfix = suffix.find_last_of ('.');
3242 if (postfix != string::npos) {
3243 suffix = suffix.substr (postfix);
3245 error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3249 const uint32_t limit = 10000;
3250 char buf[PATH_MAX+1];
3252 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3254 snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3256 if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3257 path = Glib::build_filename (dir, buf);
3265 fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3274 /** Return the full path (in some session directory) for a new within-session source.
3275 * \a name must be a session-unique name that does not contain slashes
3276 * (e.g. as returned by new_*_source_name)
3279 Session::new_source_path_from_name (DataType type, const string& name)
3281 assert(name.find("/") == string::npos);
3283 SessionDirectory sdir(get_best_session_directory_for_new_source());
3286 if (type == DataType::AUDIO) {
3287 p = sdir.sound_path();
3288 } else if (type == DataType::MIDI) {
3289 p = sdir.midi_path();
3291 error << "Unknown source type, unable to create file path" << endmsg;
3295 return Glib::build_filename (p, name);
3299 Session::peak_path (string base) const
3301 return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3304 /** Return a unique name based on \a base for a new internal audio source */
3306 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3309 char buf[PATH_MAX+1];
3310 const uint32_t limit = 10000;
3312 string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3315 legalized = legalize_for_path (base);
3317 // Find a "version" of the base name that doesn't exist in any of the possible directories.
3318 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3320 vector<space_and_path>::iterator i;
3321 uint32_t existing = 0;
3323 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3328 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3329 cnt, legalized.c_str(), ext.c_str());
3330 } else if (nchan == 2) {
3332 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3333 cnt, legalized.c_str(), ext.c_str());
3335 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3336 cnt, legalized.c_str(), ext.c_str());
3338 } else if (nchan < 26) {
3339 snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3340 cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3342 snprintf (buf, sizeof(buf), "T%04d-%s%s",
3343 cnt, legalized.c_str(), ext.c_str());
3349 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3350 } else if (nchan == 2) {
3352 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3354 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3356 } else if (nchan < 26) {
3357 snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3359 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3363 SessionDirectory sdir((*i).path);
3365 string spath = sdir.sound_path();
3367 /* note that we search *without* the extension so that
3368 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3369 in the event that this new name is required for
3370 a file format change.
3373 if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3379 if (existing == 0) {
3384 error << string_compose(
3385 _("There are already %1 recordings for %2, which I consider too many."),
3386 limit, base) << endmsg;
3388 throw failed_constructor();
3392 return Glib::path_get_basename (buf);
3395 /** Create a new within-session audio source */
3396 boost::shared_ptr<AudioFileSource>
3397 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3399 const string name = new_audio_source_name (n, n_chans, chan, destructive);
3400 const string path = new_source_path_from_name(DataType::AUDIO, name);
3402 return boost::dynamic_pointer_cast<AudioFileSource> (
3403 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3406 /** Return a unique name based on \a base for a new internal MIDI source */
3408 Session::new_midi_source_name (const string& base)
3411 char buf[PATH_MAX+1];
3412 const uint32_t limit = 10000;
3416 legalized = legalize_for_path (base);
3418 // Find a "version" of the file name that doesn't exist in any of the possible directories.
3419 for (cnt = 1; cnt <= limit; ++cnt) {
3421 vector<space_and_path>::iterator i;
3422 uint32_t existing = 0;
3424 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3426 SessionDirectory sdir((*i).path);
3428 std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3430 snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3432 if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3437 if (existing == 0) {
3442 error << string_compose(
3443 _("There are already %1 recordings for %2, which I consider too many."),
3444 limit, base) << endmsg;
3446 throw failed_constructor();
3450 return Glib::path_get_basename(buf);
3454 /** Create a new within-session MIDI source */
3455 boost::shared_ptr<MidiSource>
3456 Session::create_midi_source_for_session (Track* track, string const & n)
3458 /* try to use the existing write source for the track, to keep numbering sane
3462 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3466 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3469 assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3470 return boost::dynamic_pointer_cast<MidiSource> (l.front());
3474 const string name = new_midi_source_name (n);
3475 const string path = new_source_path_from_name (DataType::MIDI, name);
3477 return boost::dynamic_pointer_cast<SMFSource> (
3478 SourceFactory::createWritable (
3479 DataType::MIDI, *this, path, false, frame_rate()));
3484 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3486 if (playlist->hidden()) {
3490 playlists->add (playlist);
3493 playlist->release();
3500 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3502 if (_state_of_the_state & Deletion) {
3506 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3512 playlists->remove (playlist);
3518 Session::set_audition (boost::shared_ptr<Region> r)
3520 pending_audition_region = r;
3521 add_post_transport_work (PostTransportAudition);
3522 _butler->schedule_transport_work ();
3526 Session::audition_playlist ()
3528 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3529 ev->region.reset ();
3534 Session::non_realtime_set_audition ()
3536 assert (pending_audition_region);
3537 auditioner->audition_region (pending_audition_region);
3538 pending_audition_region.reset ();
3539 AuditionActive (true); /* EMIT SIGNAL */
3543 Session::audition_region (boost::shared_ptr<Region> r)
3545 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3551 Session::cancel_audition ()
3553 if (auditioner->auditioning()) {
3554 auditioner->cancel_audition ();
3555 AuditionActive (false); /* EMIT SIGNAL */
3560 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3562 if (a->is_monitor()) {
3565 if (b->is_monitor()) {
3568 return a->order_key (MixerSort) < b->order_key (MixerSort);
3572 Session::is_auditioning () const
3574 /* can be called before we have an auditioner object */
3576 return auditioner->auditioning();
3583 Session::graph_reordered ()
3585 /* don't do this stuff if we are setting up connections
3586 from a set_state() call or creating new tracks. Ditto for deletion.
3589 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3593 /* every track/bus asked for this to be handled but it was deferred because
3594 we were connecting. do it now.
3597 request_input_change_handling ();
3601 /* force all diskstreams to update their capture offset values to
3602 reflect any changes in latencies within the graph.
3605 boost::shared_ptr<RouteList> rl = routes.reader ();
3606 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3607 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3609 tr->set_capture_offset ();
3614 /** @return Number of frames that there is disk space available to write,
3617 boost::optional<framecnt_t>
3618 Session::available_capture_duration ()
3620 Glib::Threads::Mutex::Lock lm (space_lock);
3622 if (_total_free_4k_blocks_uncertain) {
3623 return boost::optional<framecnt_t> ();
3626 float sample_bytes_on_disk = 4.0; // keep gcc happy
3628 switch (config.get_native_file_data_format()) {
3630 sample_bytes_on_disk = 4.0;
3634 sample_bytes_on_disk = 3.0;
3638 sample_bytes_on_disk = 2.0;
3642 /* impossible, but keep some gcc versions happy */
3643 fatal << string_compose (_("programming error: %1"),
3644 X_("illegal native file data format"))
3649 double scale = 4096.0 / sample_bytes_on_disk;
3651 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3652 return max_framecnt;
3655 return (framecnt_t) floor (_total_free_4k_blocks * scale);
3659 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3662 RCUWriter<BundleList> writer (_bundles);
3663 boost::shared_ptr<BundleList> b = writer.get_copy ();
3664 b->push_back (bundle);
3667 BundleAdded (bundle); /* EMIT SIGNAL */
3673 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3675 bool removed = false;
3678 RCUWriter<BundleList> writer (_bundles);
3679 boost::shared_ptr<BundleList> b = writer.get_copy ();
3680 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3682 if (i != b->end()) {
3689 BundleRemoved (bundle); /* EMIT SIGNAL */
3695 boost::shared_ptr<Bundle>
3696 Session::bundle_by_name (string name) const
3698 boost::shared_ptr<BundleList> b = _bundles.reader ();
3700 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3701 if ((*i)->name() == name) {
3706 return boost::shared_ptr<Bundle> ();
3710 Session::tempo_map_changed (const PropertyChange&)
3714 playlists->update_after_tempo_map_change ();
3716 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3722 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3724 for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3725 (*i)->recompute_frames_from_bbt ();
3729 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3730 * the given count with the current block size.
3733 Session::ensure_buffers (ChanCount howmany)
3735 BufferManager::ensure_buffers (howmany);
3739 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3741 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3742 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3747 Session::next_insert_id ()
3749 /* this doesn't really loop forever. just think about it */
3752 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3753 if (!insert_bitset[n]) {
3754 insert_bitset[n] = true;
3760 /* none available, so resize and try again */
3762 insert_bitset.resize (insert_bitset.size() + 16, false);
3767 Session::next_send_id ()
3769 /* this doesn't really loop forever. just think about it */
3772 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3773 if (!send_bitset[n]) {
3774 send_bitset[n] = true;
3780 /* none available, so resize and try again */
3782 send_bitset.resize (send_bitset.size() + 16, false);
3787 Session::next_aux_send_id ()
3789 /* this doesn't really loop forever. just think about it */
3792 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3793 if (!aux_send_bitset[n]) {
3794 aux_send_bitset[n] = true;
3800 /* none available, so resize and try again */
3802 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3807 Session::next_return_id ()
3809 /* this doesn't really loop forever. just think about it */
3812 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3813 if (!return_bitset[n]) {
3814 return_bitset[n] = true;
3820 /* none available, so resize and try again */
3822 return_bitset.resize (return_bitset.size() + 16, false);
3827 Session::mark_send_id (uint32_t id)
3829 if (id >= send_bitset.size()) {
3830 send_bitset.resize (id+16, false);
3832 if (send_bitset[id]) {
3833 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3835 send_bitset[id] = true;
3839 Session::mark_aux_send_id (uint32_t id)
3841 if (id >= aux_send_bitset.size()) {
3842 aux_send_bitset.resize (id+16, false);
3844 if (aux_send_bitset[id]) {
3845 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3847 aux_send_bitset[id] = true;
3851 Session::mark_return_id (uint32_t id)
3853 if (id >= return_bitset.size()) {
3854 return_bitset.resize (id+16, false);
3856 if (return_bitset[id]) {
3857 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3859 return_bitset[id] = true;
3863 Session::mark_insert_id (uint32_t id)
3865 if (id >= insert_bitset.size()) {
3866 insert_bitset.resize (id+16, false);
3868 if (insert_bitset[id]) {
3869 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3871 insert_bitset[id] = true;
3875 Session::unmark_send_id (uint32_t id)
3877 if (id < send_bitset.size()) {
3878 send_bitset[id] = false;
3883 Session::unmark_aux_send_id (uint32_t id)
3885 if (id < aux_send_bitset.size()) {
3886 aux_send_bitset[id] = false;
3891 Session::unmark_return_id (uint32_t id)
3893 if (id < return_bitset.size()) {
3894 return_bitset[id] = false;
3899 Session::unmark_insert_id (uint32_t id)
3901 if (id < insert_bitset.size()) {
3902 insert_bitset[id] = false;
3907 Session::reset_native_file_format ()
3909 boost::shared_ptr<RouteList> rl = routes.reader ();
3910 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3911 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3913 /* don't save state as we do this, there's no point
3916 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3917 tr->reset_write_sources (false);
3918 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3924 Session::route_name_unique (string n) const
3926 boost::shared_ptr<RouteList> r = routes.reader ();
3928 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3929 if ((*i)->name() == n) {
3938 Session::route_name_internal (string n) const
3940 if (auditioner && auditioner->name() == n) {
3944 if (_click_io && _click_io->name() == n) {
3952 Session::freeze_all (InterThreadInfo& itt)
3954 boost::shared_ptr<RouteList> r = routes.reader ();
3956 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3958 boost::shared_ptr<Track> t;
3960 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3961 /* XXX this is wrong because itt.progress will keep returning to zero at the start
3971 boost::shared_ptr<Region>
3972 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3973 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3974 InterThreadInfo& itt,
3975 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
3978 boost::shared_ptr<Region> result;
3979 boost::shared_ptr<Playlist> playlist;
3980 boost::shared_ptr<AudioFileSource> fsource;
3982 char buf[PATH_MAX+1];
3983 ChanCount diskstream_channels (track.n_channels());
3984 framepos_t position;
3985 framecnt_t this_chunk;
3988 SessionDirectory sdir(get_best_session_directory_for_new_source ());
3989 const string sound_dir = sdir.sound_path();
3990 framepos_t len = end - start;
3991 bool need_block_size_reset = false;
3993 ChanCount const max_proc = track.max_processor_streams ();
3996 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3997 end, start) << endmsg;
4001 const framecnt_t chunk_size = (256 * 1024)/4;
4003 // block all process callback handling
4005 block_processing ();
4007 /* call tree *MUST* hold route_lock */
4009 if ((playlist = track.playlist()) == 0) {
4013 ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4015 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
4017 for (x = 0; x < 99999; ++x) {
4018 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());
4019 if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
4025 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4030 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4031 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
4034 catch (failed_constructor& err) {
4035 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4039 srcs.push_back (fsource);
4042 /* tell redirects that care that we are about to use a much larger
4043 * blocksize. this will flush all plugins too, so that they are ready
4044 * to be used for this process.
4047 need_block_size_reset = true;
4048 track.set_block_size (chunk_size);
4053 /* create a set of reasonably-sized buffers */
4054 buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4055 buffers.set_count (max_proc);
4057 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4058 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4060 afs->prepare_for_peakfile_writes ();
4063 while (to_do && !itt.cancel) {
4065 this_chunk = min (to_do, chunk_size);
4067 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4072 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4073 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4076 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4082 start += this_chunk;
4083 to_do -= this_chunk;
4085 itt.progress = (float) (1.0 - ((double) to_do / len));
4094 xnow = localtime (&now);
4096 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4097 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4100 afs->update_header (position, *xnow, now);
4101 afs->flush_header ();
4105 /* construct a region to represent the bounced material */
4109 plist.add (Properties::start, 0);
4110 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4111 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4113 result = RegionFactory::create (srcs, plist);
4119 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4120 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4123 afs->mark_for_remove ();
4126 (*src)->drop_references ();
4130 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4131 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4134 afs->done_with_peakfile_writes ();
4139 if (need_block_size_reset) {
4140 track.set_block_size (get_block_size());
4143 unblock_processing ();
4149 Session::gain_automation_buffer() const
4151 return ProcessThread::gain_automation_buffer ();
4155 Session::send_gain_automation_buffer() const
4157 return ProcessThread::send_gain_automation_buffer ();
4161 Session::pan_automation_buffer() const
4163 return ProcessThread::pan_automation_buffer ();
4167 Session::get_silent_buffers (ChanCount count)
4169 return ProcessThread::get_silent_buffers (count);
4173 Session::get_scratch_buffers (ChanCount count)
4175 return ProcessThread::get_scratch_buffers (count);
4179 Session::get_mix_buffers (ChanCount count)
4181 return ProcessThread::get_mix_buffers (count);
4185 Session::ntracks () const
4188 boost::shared_ptr<RouteList> r = routes.reader ();
4190 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4191 if (boost::dynamic_pointer_cast<Track> (*i)) {
4200 Session::nbusses () const
4203 boost::shared_ptr<RouteList> r = routes.reader ();
4205 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4206 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4215 Session::add_automation_list(AutomationList *al)
4217 automation_lists[al->id()] = al;
4220 /** @return true if there is at least one record-enabled track, otherwise false */
4222 Session::have_rec_enabled_track () const
4224 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4227 /** Update the state of our rec-enabled tracks flag */
4229 Session::update_have_rec_enabled_track ()
4231 boost::shared_ptr<RouteList> rl = routes.reader ();
4232 RouteList::iterator i = rl->begin();
4233 while (i != rl->end ()) {
4235 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4236 if (tr && tr->record_enabled ()) {
4243 int const old = g_atomic_int_get (&_have_rec_enabled_track);
4245 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4247 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4248 RecordStateChanged (); /* EMIT SIGNAL */
4253 Session::listen_position_changed ()
4255 boost::shared_ptr<RouteList> r = routes.reader ();
4257 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4258 (*i)->listen_position_changed ();
4263 Session::solo_control_mode_changed ()
4265 /* cancel all solo or all listen when solo control mode changes */
4268 set_solo (get_routes(), false);
4269 } else if (listening()) {
4270 set_listen (get_routes(), false);
4274 /** Called when a property of one of our route groups changes */
4276 Session::route_group_property_changed (RouteGroup* rg)
4278 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4281 /** Called when a route is added to one of our route groups */
4283 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4285 RouteAddedToRouteGroup (rg, r);
4288 /** Called when a route is removed from one of our route groups */
4290 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4292 RouteRemovedFromRouteGroup (rg, r);
4295 boost::shared_ptr<RouteList>
4296 Session::get_routes_with_regions_at (framepos_t const p) const
4298 boost::shared_ptr<RouteList> r = routes.reader ();
4299 boost::shared_ptr<RouteList> rl (new RouteList);
4301 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4302 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4307 boost::shared_ptr<Playlist> pl = tr->playlist ();
4312 if (pl->has_region_at (p)) {
4321 Session::goto_end ()
4323 if (_session_range_location) {
4324 request_locate (_session_range_location->end(), false);
4326 request_locate (0, false);
4331 Session::goto_start ()
4333 if (_session_range_location) {
4334 request_locate (_session_range_location->start(), false);
4336 request_locate (0, false);
4341 Session::current_start_frame () const
4343 return _session_range_location ? _session_range_location->start() : 0;
4347 Session::current_end_frame () const
4349 return _session_range_location ? _session_range_location->end() : 0;
4353 Session::add_session_range_location (framepos_t start, framepos_t end)
4355 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4356 _locations->add (_session_range_location);
4360 Session::step_edit_status_change (bool yn)
4366 send = (_step_editors == 0);
4371 send = (_step_editors == 1);
4374 if (_step_editors > 0) {
4380 StepEditStatusChange (val);
4386 Session::start_time_changed (framepos_t old)
4388 /* Update the auto loop range to match the session range
4389 (unless the auto loop range has been changed by the user)
4392 Location* s = _locations->session_range_location ();
4397 Location* l = _locations->auto_loop_location ();
4399 if (l && l->start() == old) {
4400 l->set_start (s->start(), true);
4405 Session::end_time_changed (framepos_t old)
4407 /* Update the auto loop range to match the session range
4408 (unless the auto loop range has been changed by the user)
4411 Location* s = _locations->session_range_location ();
4416 Location* l = _locations->auto_loop_location ();
4418 if (l && l->end() == old) {
4419 l->set_end (s->end(), true);
4424 Session::source_search_path (DataType type) const
4428 if (session_dirs.size() == 1) {
4430 case DataType::AUDIO:
4431 s.push_back (_session_dir->sound_path());
4433 case DataType::MIDI:
4434 s.push_back (_session_dir->midi_path());
4438 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4439 SessionDirectory sdir (i->path);
4441 case DataType::AUDIO:
4442 s.push_back (sdir.sound_path());
4444 case DataType::MIDI:
4445 s.push_back (sdir.midi_path());
4451 if (type == DataType::AUDIO) {
4452 const string sound_path_2X = _session_dir->sound_path_2X();
4453 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4454 if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
4455 s.push_back (sound_path_2X);
4460 /* now check the explicit (possibly user-specified) search path
4463 vector<string> dirs;
4466 case DataType::AUDIO:
4467 split (config.get_audio_search_path (), dirs, ':');
4469 case DataType::MIDI:
4470 split (config.get_midi_search_path (), dirs, ':');
4474 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4475 if (find (s.begin(), s.end(), *i) == s.end()) {
4482 for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4483 if (!search_path.empty()) {
4493 Session::ensure_search_path_includes (const string& path, DataType type)
4496 vector<string> dirs;
4503 case DataType::AUDIO:
4504 search_path = config.get_audio_search_path ();
4506 case DataType::MIDI:
4507 search_path = config.get_midi_search_path ();
4511 split (search_path, dirs, ':');
4513 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4514 /* No need to add this new directory if it has the same inode as
4515 an existing one; checking inode rather than name prevents duplicated
4516 directories when we are using symlinks.
4518 On Windows, I think we could just do if (*i == path) here.
4520 if (PBD::equivalent_paths (*i, path)) {
4525 if (!search_path.empty()) {
4529 search_path += path;
4532 case DataType::AUDIO:
4533 config.set_audio_search_path (search_path);
4535 case DataType::MIDI:
4536 config.set_midi_search_path (search_path);
4541 boost::shared_ptr<Speakers>
4542 Session::get_speakers()
4548 Session::unknown_processors () const
4552 boost::shared_ptr<RouteList> r = routes.reader ();
4553 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4554 list<string> t = (*i)->unknown_processors ();
4555 copy (t.begin(), t.end(), back_inserter (p));
4565 Session::update_latency (bool playback)
4567 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4569 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4573 boost::shared_ptr<RouteList> r = routes.reader ();
4574 framecnt_t max_latency = 0;
4577 /* reverse the list so that we work backwards from the last route to run to the first */
4578 RouteList* rl = routes.reader().get();
4579 r.reset (new RouteList (*rl));
4580 reverse (r->begin(), r->end());
4583 /* compute actual latency values for the given direction and store them all in per-port
4584 structures. this will also publish the same values (to JACK) so that computation of latency
4585 for routes can consistently use public latency values.
4588 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4589 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4592 /* because we latency compensate playback, our published playback latencies should
4593 be the same for all output ports - all material played back by ardour has
4594 the same latency, whether its caused by plugins or by latency compensation. since
4595 these may differ from the values computed above, reset all playback port latencies
4599 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4601 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4602 (*i)->set_public_port_latencies (max_latency, playback);
4607 post_playback_latency ();
4611 post_capture_latency ();
4614 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4618 Session::post_playback_latency ()
4620 set_worst_playback_latency ();
4622 boost::shared_ptr<RouteList> r = routes.reader ();
4624 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4625 if (!(*i)->is_auditioner() && ((*i)->active())) {
4626 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4630 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4631 (*i)->set_latency_compensation (_worst_track_latency);
4636 Session::post_capture_latency ()
4638 set_worst_capture_latency ();
4640 /* reflect any changes in capture latencies into capture offsets
4643 boost::shared_ptr<RouteList> rl = routes.reader();
4644 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4645 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4647 tr->set_capture_offset ();
4653 Session::initialize_latencies ()
4656 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4657 update_latency (false);
4658 update_latency (true);
4661 set_worst_io_latencies ();
4665 Session::set_worst_io_latencies ()
4667 set_worst_playback_latency ();
4668 set_worst_capture_latency ();
4672 Session::set_worst_playback_latency ()
4674 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4678 _worst_output_latency = 0;
4680 if (!_engine.connected()) {
4684 boost::shared_ptr<RouteList> r = routes.reader ();
4686 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4687 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4690 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4694 Session::set_worst_capture_latency ()
4696 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4700 _worst_input_latency = 0;
4702 if (!_engine.connected()) {
4706 boost::shared_ptr<RouteList> r = routes.reader ();
4708 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4709 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4712 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4716 Session::update_latency_compensation (bool force_whole_graph)
4718 bool some_track_latency_changed = false;
4720 if (_state_of_the_state & (InitialConnecting|Deletion)) {
4724 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4726 _worst_track_latency = 0;
4728 boost::shared_ptr<RouteList> r = routes.reader ();
4730 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4731 if (!(*i)->is_auditioner() && ((*i)->active())) {
4733 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4734 some_track_latency_changed = true;
4736 _worst_track_latency = max (tl, _worst_track_latency);
4740 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4741 (some_track_latency_changed ? "yes" : "no")));
4743 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4745 if (some_track_latency_changed || force_whole_graph) {
4746 _engine.update_latencies ();
4750 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4751 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4755 tr->set_capture_offset ();
4760 Session::session_name_is_legal (const string& path)
4762 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4764 for (int i = 0; illegal_chars[i]; ++i) {
4765 if (path.find (illegal_chars[i]) != string::npos) {
4766 return illegal_chars[i];
4774 Session::next_control_id () const
4778 /* the monitor bus remote ID is in a different
4779 * "namespace" than regular routes. its existence doesn't
4780 * affect normal (low) numbered routes.
4787 return nroutes() - subtract;
4791 Session::notify_remote_id_change ()
4793 if (deletion_in_progress()) {
4797 switch (Config->get_remote_model()) {
4800 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4808 Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
4810 if (deletion_in_progress()) {
4814 /* tell everyone that something has happened to the sort keys
4815 and let them sync up with the change(s)
4816 this will give objects that manage the sort order keys the
4817 opportunity to keep them in sync if they wish to.
4820 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
4822 Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
4824 DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
4828 Session::operation_in_progress (GQuark op) const
4830 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4833 boost::shared_ptr<Port>
4834 Session::ltc_input_port () const
4836 return _ltc_input->nth (0);
4839 boost::shared_ptr<Port>
4840 Session::ltc_output_port () const
4842 return _ltc_output->nth (0);
4846 Session::reconnect_ltc_input ()
4850 string src = Config->get_ltc_source_port();
4852 _ltc_input->disconnect (this);
4854 if (src != _("None") && !src.empty()) {
4855 _ltc_input->nth (0)->connect (src);
4861 Session::reconnect_ltc_output ()
4866 string src = Config->get_ltc_sink_port();
4868 _ltc_output->disconnect (this);
4870 if (src != _("None") && !src.empty()) {
4871 _ltc_output->nth (0)->connect (src);