2 Copyright (C) 1999-2010 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <cstdio> /* sprintf(3) ... grrr */
33 #include <glibmm/thread.h>
34 #include <glibmm/miscutils.h>
35 #include <glibmm/fileutils.h>
37 #include <boost/algorithm/string/erase.hpp>
39 #include "pbd/error.h"
40 #include "pbd/boost_debug.h"
41 #include "pbd/pathscanner.h"
42 #include "pbd/stl_delete.h"
43 #include "pbd/basename.h"
44 #include "pbd/stacktrace.h"
45 #include "pbd/file_utils.h"
46 #include "pbd/convert.h"
47 #include "pbd/strsplit.h"
49 #include "ardour/amp.h"
50 #include "ardour/analyser.h"
51 #include "ardour/audio_buffer.h"
52 #include "ardour/audio_diskstream.h"
53 #include "ardour/audio_port.h"
54 #include "ardour/audio_track.h"
55 #include "ardour/audioengine.h"
56 #include "ardour/audiofilesource.h"
57 #include "ardour/audioplaylist.h"
58 #include "ardour/audioregion.h"
59 #include "ardour/auditioner.h"
60 #include "ardour/buffer_manager.h"
61 #include "ardour/buffer_set.h"
62 #include "ardour/bundle.h"
63 #include "ardour/butler.h"
64 #include "ardour/click.h"
65 #include "ardour/configuration.h"
66 #include "ardour/crossfade.h"
67 #include "ardour/cycle_timer.h"
68 #include "ardour/data_type.h"
69 #include "ardour/debug.h"
70 #include "ardour/filename_extensions.h"
71 #include "ardour/internal_send.h"
72 #include "ardour/io_processor.h"
73 #include "ardour/midi_diskstream.h"
74 #include "ardour/midi_playlist.h"
75 #include "ardour/midi_region.h"
76 #include "ardour/midi_track.h"
77 #include "ardour/midi_ui.h"
78 #include "ardour/named_selection.h"
79 #include "ardour/process_thread.h"
80 #include "ardour/playlist.h"
81 #include "ardour/plugin_insert.h"
82 #include "ardour/port_insert.h"
83 #include "ardour/processor.h"
84 #include "ardour/rc_configuration.h"
85 #include "ardour/recent_sessions.h"
86 #include "ardour/region_factory.h"
87 #include "ardour/return.h"
88 #include "ardour/route_group.h"
89 #include "ardour/send.h"
90 #include "ardour/session.h"
91 #include "ardour/session_directory.h"
92 #include "ardour/session_directory.h"
93 #include "ardour/session_metadata.h"
94 #include "ardour/session_playlists.h"
95 #include "ardour/slave.h"
96 #include "ardour/smf_source.h"
97 #include "ardour/source_factory.h"
98 #include "ardour/tape_file_matcher.h"
99 #include "ardour/tempo.h"
100 #include "ardour/utils.h"
101 #include "ardour/graph.h"
102 #include "ardour/speakers.h"
103 #include "ardour/operations.h"
105 #include "midi++/port.h"
106 #include "midi++/mmc.h"
107 #include "midi++/manager.h"
112 using namespace ARDOUR;
115 bool Session::_disable_all_loaded_plugins = false;
117 PBD::Signal1<void,std::string> Session::Dialog;
118 PBD::Signal0<int> Session::AskAboutPendingState;
119 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
120 PBD::Signal0<void> Session::SendFeedback;
121 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
123 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
124 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
125 PBD::Signal0<void> Session::AutoBindingOn;
126 PBD::Signal0<void> Session::AutoBindingOff;
127 PBD::Signal2<void,std::string, std::string> Session::Exported;
128 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
129 PBD::Signal0<void> Session::Quit;
131 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
132 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
134 Session::Session (AudioEngine &eng,
135 const string& fullpath,
136 const string& snapshot_name,
137 BusProfile* bus_profile,
140 , _target_transport_speed (0.0)
141 , _requested_return_frame (-1)
142 , _session_dir (new SessionDirectory(fullpath))
144 , _state_of_the_state (Clean)
145 , _butler (new Butler (*this))
146 , _post_transport_work (0)
147 , _send_timecode_update (false)
148 , _all_route_group (new RouteGroup (*this, "all"))
149 , route_graph (new Graph(*this))
150 , routes (new RouteList)
151 , _total_free_4k_blocks (0)
152 , _bundles (new BundleList)
153 , _bundle_xml_node (0)
155 , _click_io ((IO*) 0)
157 , click_emphasis_data (0)
159 , _metadata (new SessionMetadata())
160 , _have_rec_enabled_track (false)
161 , _suspend_timecode_transmission (0)
163 _locations = new Locations (*this);
165 playlists.reset (new SessionPlaylists);
167 _all_route_group->set_active (true, this);
169 interpolation.add_channel_to (0, 0);
171 if (!eng.connected()) {
172 throw failed_constructor();
175 n_physical_outputs = _engine.n_physical_outputs ();
176 n_physical_inputs = _engine.n_physical_inputs ();
178 first_stage_init (fullpath, snapshot_name);
180 _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
183 if (create (mix_template, bus_profile)) {
185 throw failed_constructor ();
189 if (second_stage_init ()) {
191 throw failed_constructor ();
194 store_recent_sessions(_name, _path);
196 bool was_dirty = dirty();
198 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
200 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
201 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
204 DirtyChanged (); /* EMIT SIGNAL */
207 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
208 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
221 vector<void*> debug_pointers;
223 /* if we got to here, leaving pending capture state around
227 remove_pending_capture_state ();
229 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
231 _engine.remove_session ();
233 /* clear history so that no references to objects are held any more */
237 /* clear state tree so that no references to objects are held any more */
241 /* remove all stubfiles that might still be lurking */
243 cleanup_stubfiles ();
245 /* reset dynamic state version back to default */
247 Stateful::loading_state_version = 0;
249 _butler->drop_references ();
251 delete midi_control_ui;
252 delete _all_route_group;
254 if (click_data != default_click) {
255 delete [] click_data;
258 if (click_emphasis_data != default_click_emphasis) {
259 delete [] click_emphasis_data;
264 /* clear out any pending dead wood from RCU managed objects */
269 AudioDiskstream::free_working_buffers();
271 /* tell everyone who is still standing that we're about to die */
274 /* tell everyone to drop references and delete objects as we go */
276 DEBUG_TRACE (DEBUG::Destruction, "delete named selections\n");
277 named_selections.clear ();
279 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
280 RegionFactory::delete_all_regions ();
282 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
284 /* reset these three references to special routes before we do the usual route delete thing */
287 _master_out.reset ();
288 _monitor_out.reset ();
291 RCUWriter<RouteList> writer (routes);
292 boost::shared_ptr<RouteList> r = writer.get_copy ();
294 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
295 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
296 (*i)->drop_references ();
300 /* writer goes out of scope and updates master */
304 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
305 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
307 SourceMap::iterator j = i;
310 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->path(), i->second.use_count()));
311 i->second->drop_references ();
318 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
319 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
324 Crossfade::set_buffer_size (0);
326 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
331 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
333 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
334 boost_debug_list_ptrs ();
339 Session::set_worst_io_latencies ()
341 _worst_output_latency = 0;
342 _worst_input_latency = 0;
344 if (!_engine.connected()) {
348 boost::shared_ptr<RouteList> r = routes.reader ();
350 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
351 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
352 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
357 Session::when_engine_running ()
359 string first_physical_output;
361 BootMessage (_("Set block size and sample rate"));
363 set_block_size (_engine.frames_per_cycle());
364 set_frame_rate (_engine.frame_rate());
366 BootMessage (_("Using configuration"));
368 boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
369 boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
371 Config->map_parameters (ff);
372 config.map_parameters (ft);
374 /* every time we reconnect, recompute worst case output latencies */
376 _engine.Running.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies, this));
378 if (synced_to_jack()) {
379 _engine.transport_stop ();
382 if (config.get_jack_time_master()) {
383 _engine.transport_locate (_transport_frame);
391 _click_io.reset (new ClickIO (*this, "click"));
393 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
395 /* existing state for Click */
398 if (Stateful::loading_state_version < 3000) {
399 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
401 c = _click_io->set_state (*child->children().front(), Stateful::loading_state_version);
406 _clicking = Config->get_clicking ();
410 error << _("could not setup Click I/O") << endmsg;
417 /* default state for Click: dual-mono to first 2 physical outputs */
420 _engine.get_physical_outputs (DataType::AUDIO, outs);
422 for (uint32_t physport = 0; physport < 2; ++physport) {
423 if (outs.size() > physport) {
424 if (_click_io->add_port (outs[physport], this)) {
425 // relax, even though its an error
430 if (_click_io->n_ports () > ChanCount::ZERO) {
431 _clicking = Config->get_clicking ();
436 catch (failed_constructor& err) {
437 error << _("cannot setup Click I/O") << endmsg;
440 BootMessage (_("Compute I/O Latencies"));
442 set_worst_io_latencies ();
445 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
448 BootMessage (_("Set up standard connections"));
450 vector<string> inputs[DataType::num_types];
451 vector<string> outputs[DataType::num_types];
452 for (uint32_t i = 0; i < DataType::num_types; ++i) {
453 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
454 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
457 /* Create a set of Bundle objects that map
458 to the physical I/O currently available. We create both
459 mono and stereo bundles, so that the common cases of mono
460 and stereo tracks get bundles to put in their mixer strip
461 in / out menus. There may be a nicer way of achieving that;
462 it doesn't really scale that well to higher channel counts
465 /* mono output bundles */
467 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
469 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
471 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
472 c->add_channel (_("mono"), DataType::AUDIO);
473 c->set_port (0, outputs[DataType::AUDIO][np]);
478 /* stereo output bundles */
480 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
481 if (np + 1 < outputs[DataType::AUDIO].size()) {
483 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
484 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
485 c->add_channel (_("L"), DataType::AUDIO);
486 c->set_port (0, outputs[DataType::AUDIO][np]);
487 c->add_channel (_("R"), DataType::AUDIO);
488 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
494 /* mono input bundles */
496 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
498 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
500 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
501 c->add_channel (_("mono"), DataType::AUDIO);
502 c->set_port (0, inputs[DataType::AUDIO][np]);
507 /* stereo input bundles */
509 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
510 if (np + 1 < inputs[DataType::AUDIO].size()) {
512 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
514 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
515 c->add_channel (_("L"), DataType::AUDIO);
516 c->set_port (0, inputs[DataType::AUDIO][np]);
517 c->add_channel (_("R"), DataType::AUDIO);
518 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
524 /* MIDI input bundles */
526 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
527 string n = inputs[DataType::MIDI][np];
528 boost::erase_first (n, X_("alsa_pcm:"));
530 boost::shared_ptr<Bundle> c (new Bundle (n, false));
531 c->add_channel ("", DataType::MIDI);
532 c->set_port (0, inputs[DataType::MIDI][np]);
536 /* MIDI output bundles */
538 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
539 string n = outputs[DataType::MIDI][np];
540 boost::erase_first (n, X_("alsa_pcm:"));
542 boost::shared_ptr<Bundle> c (new Bundle (n, true));
543 c->add_channel ("", DataType::MIDI);
544 c->set_port (0, outputs[DataType::MIDI][np]);
548 BootMessage (_("Setup signal flow and plugins"));
552 if (_is_new && !no_auto_connect()) {
554 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
556 /* don't connect the master bus outputs if there is a monitor bus */
558 if (_master_out && Config->get_auto_connect_standard_busses() && !_monitor_out) {
560 /* if requested auto-connect the outputs to the first N physical ports.
563 uint32_t limit = _master_out->n_outputs().n_total();
565 for (uint32_t n = 0; n < limit; ++n) {
566 Port* p = _master_out->output()->nth (n);
568 if (outputs[p->type()].size() > n) {
569 connect_to = outputs[p->type()][n];
572 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
573 if (_master_out->output()->connect (p, connect_to, this)) {
574 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
584 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
585 are undefined, at best.
588 /* control out listens to master bus (but ignores it
589 under some conditions)
592 uint32_t limit = _monitor_out->n_inputs().n_audio();
595 for (uint32_t n = 0; n < limit; ++n) {
596 AudioPort* p = _monitor_out->input()->ports().nth_audio_port (n);
597 AudioPort* o = _master_out->output()->ports().nth_audio_port (n);
600 string connect_to = o->name();
601 if (_monitor_out->input()->connect (p, connect_to, this)) {
602 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
610 /* if control out is not connected, connect control out to physical outs
613 if (!_monitor_out->output()->connected ()) {
615 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
617 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
620 _monitor_out->output()->connect_ports_to_bundle (b, this);
622 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
623 Config->get_monitor_bus_preferred_bundle())
629 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
630 uint32_t mod = n_physical_outputs.get (*t);
631 uint32_t limit = _monitor_out->n_outputs().get(*t);
633 for (uint32_t n = 0; n < limit; ++n) {
635 Port* p = _monitor_out->output()->ports().port(*t, n);
637 if (outputs[*t].size() > (n % mod)) {
638 connect_to = outputs[*t][n % mod];
641 if (!connect_to.empty()) {
642 if (_monitor_out->output()->connect (p, connect_to, this)) {
643 error << string_compose (
644 _("cannot connect control output %1 to %2"),
657 /* catch up on send+insert cnts */
659 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
661 /* hook us up to the engine */
663 BootMessage (_("Connect to engine"));
665 _engine.set_session (this);
666 _engine.update_total_latencies ();
670 Session::hookup_io ()
672 /* stop graph reordering notifications from
673 causing resorts, etc.
676 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
680 /* we delay creating the auditioner till now because
681 it makes its own connections to ports.
685 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
687 throw failed_constructor ();
689 a->use_new_diskstream ();
693 catch (failed_constructor& err) {
694 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
698 /* load bundles, which we may have postponed earlier on */
699 if (_bundle_xml_node) {
700 load_bundles (*_bundle_xml_node);
701 delete _bundle_xml_node;
704 /* Tell all IO objects to connect themselves together */
706 IO::enable_connecting ();
707 MIDI::Port::MakeConnections ();
709 /* Now reset all panners */
711 Delivery::reset_panners ();
713 /* Connect tracks to monitor/listen bus if there is one.
714 Note that in an existing session, the internal sends will
715 already exist, but we want the routes to notice that
716 they connect to the control out specifically.
720 boost::shared_ptr<RouteList> r = routes.reader ();
721 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
723 if ((*x)->is_monitor()) {
727 } else if ((*x)->is_master()) {
733 (*x)->listen_via_monitor ();
738 /* Anyone who cares about input state, wake up and do something */
740 IOConnectionsComplete (); /* EMIT SIGNAL */
742 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
744 /* now handle the whole enchilada as if it was one
750 /* update the full solo state, which can't be
751 correctly determined on a per-route basis, but
752 needs the global overview that only the session
756 update_route_solo_state ();
760 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
762 boost::shared_ptr<Track> track = wp.lock ();
767 boost::shared_ptr<Playlist> playlist;
769 if ((playlist = track->playlist()) != 0) {
770 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
771 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
772 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
777 Session::record_enabling_legal () const
779 /* this used to be in here, but survey says.... we don't need to restrict it */
780 // if (record_status() == Recording) {
784 if (Config->get_all_safe()) {
791 Session::reset_input_monitor_state ()
793 if (transport_rolling()) {
795 boost::shared_ptr<RouteList> rl = routes.reader ();
796 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
797 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
798 if (tr && tr->record_enabled ()) {
799 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
800 tr->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
806 boost::shared_ptr<RouteList> rl = routes.reader ();
807 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
808 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
809 if (tr && tr->record_enabled ()) {
810 //cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
811 tr->monitor_input (Config->get_monitoring_model() == HardwareMonitoring);
818 Session::auto_punch_start_changed (Location* location)
820 replace_event (SessionEvent::PunchIn, location->start());
822 if (get_record_enabled() && config.get_punch_in()) {
823 /* capture start has been changed, so save new pending state */
824 save_state ("", true);
829 Session::auto_punch_end_changed (Location* location)
831 framepos_t when_to_stop = location->end();
832 // when_to_stop += _worst_output_latency + _worst_input_latency;
833 replace_event (SessionEvent::PunchOut, when_to_stop);
837 Session::auto_punch_changed (Location* location)
839 framepos_t when_to_stop = location->end();
841 replace_event (SessionEvent::PunchIn, location->start());
842 //when_to_stop += _worst_output_latency + _worst_input_latency;
843 replace_event (SessionEvent::PunchOut, when_to_stop);
847 Session::auto_loop_changed (Location* location)
849 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
851 if (transport_rolling() && play_loop) {
854 // if (_transport_frame > location->end()) {
856 if (_transport_frame < location->start() || _transport_frame > location->end()) {
857 // relocate to beginning of loop
858 clear_events (SessionEvent::LocateRoll);
860 request_locate (location->start(), true);
863 else if (Config->get_seamless_loop() && !loop_changing) {
865 // schedule a locate-roll to refill the diskstreams at the
867 loop_changing = true;
869 if (location->end() > last_loopend) {
870 clear_events (SessionEvent::LocateRoll);
871 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
878 last_loopend = location->end();
882 Session::set_auto_punch_location (Location* location)
886 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
887 punch_connections.drop_connections();
888 existing->set_auto_punch (false, this);
889 remove_event (existing->start(), SessionEvent::PunchIn);
890 clear_events (SessionEvent::PunchOut);
891 auto_punch_location_changed (0);
900 if (location->end() <= location->start()) {
901 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
905 punch_connections.drop_connections ();
907 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
908 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
909 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
911 location->set_auto_punch (true, this);
913 auto_punch_changed (location);
915 auto_punch_location_changed (location);
919 Session::set_auto_loop_location (Location* location)
923 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
924 loop_connections.drop_connections ();
925 existing->set_auto_loop (false, this);
926 remove_event (existing->end(), SessionEvent::AutoLoop);
927 auto_loop_location_changed (0);
936 if (location->end() <= location->start()) {
937 error << _("Session: you can't use a mark for auto loop") << endmsg;
941 last_loopend = location->end();
943 loop_connections.drop_connections ();
945 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
946 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
947 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
949 location->set_auto_loop (true, this);
951 /* take care of our stuff first */
953 auto_loop_changed (location);
955 /* now tell everyone else */
957 auto_loop_location_changed (location);
961 Session::locations_added (Location *)
967 Session::locations_changed ()
969 _locations->apply (*this, &Session::handle_locations_changed);
973 Session::handle_locations_changed (Locations::LocationList& locations)
975 Locations::LocationList::iterator i;
977 bool set_loop = false;
978 bool set_punch = false;
980 for (i = locations.begin(); i != locations.end(); ++i) {
984 if (location->is_auto_punch()) {
985 set_auto_punch_location (location);
988 if (location->is_auto_loop()) {
989 set_auto_loop_location (location);
993 if (location->is_session_range()) {
994 _session_range_location = location;
999 set_auto_loop_location (0);
1002 set_auto_punch_location (0);
1009 Session::enable_record ()
1012 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1014 if (rs == Recording) {
1018 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1020 _last_record_location = _transport_frame;
1021 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1023 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1025 boost::shared_ptr<RouteList> rl = routes.reader ();
1026 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1027 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1028 if (tr && tr->record_enabled ()) {
1029 tr->monitor_input (true);
1034 RecordStateChanged ();
1041 Session::disable_record (bool rt_context, bool force)
1045 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1047 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1048 g_atomic_int_set (&_record_status, Disabled);
1049 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1051 if (rs == Recording) {
1052 g_atomic_int_set (&_record_status, Enabled);
1056 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1058 boost::shared_ptr<RouteList> rl = routes.reader ();
1059 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1060 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1061 if (tr && tr->record_enabled ()) {
1062 tr->monitor_input (false);
1067 RecordStateChanged (); /* emit signal */
1070 remove_pending_capture_state ();
1076 Session::step_back_from_record ()
1078 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1080 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1081 boost::shared_ptr<RouteList> rl = routes.reader ();
1082 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1083 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1084 if (tr && tr->record_enabled ()) {
1085 //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
1086 tr->monitor_input (false);
1094 Session::maybe_enable_record ()
1096 if (_step_editors > 0) {
1100 g_atomic_int_set (&_record_status, Enabled);
1102 /* This function is currently called from somewhere other than an RT thread.
1103 This save_state() call therefore doesn't impact anything. Doing it here
1104 means that we save pending state of which sources the next record will use,
1105 which gives us some chance of recovering from a crash during the record.
1108 save_state ("", true);
1110 if (_transport_speed) {
1111 if (!config.get_punch_in()) {
1115 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1116 RecordStateChanged (); /* EMIT SIGNAL */
1123 Session::audible_frame () const
1129 /* the first of these two possible settings for "offset"
1130 mean that the audible frame is stationary until
1131 audio emerges from the latency compensation
1134 the second means that the audible frame is stationary
1135 until audio would emerge from a physical port
1136 in the absence of any plugin latency compensation
1139 offset = _worst_output_latency;
1141 if (offset > current_block_size) {
1142 offset -= current_block_size;
1144 /* XXX is this correct? if we have no external
1145 physical connections and everything is internal
1146 then surely this is zero? still, how
1147 likely is that anyway?
1149 offset = current_block_size;
1152 if (synced_to_jack()) {
1153 tf = _engine.transport_frame();
1155 tf = _transport_frame;
1160 if (!non_realtime_work_pending()) {
1164 /* Check to see if we have passed the first guaranteed
1165 audible frame past our last start position. if not,
1166 return that last start point because in terms
1167 of audible frames, we have not moved yet.
1169 `Start position' in this context means the time we last
1170 either started or changed transport direction.
1173 if (_transport_speed > 0.0f) {
1175 if (!play_loop || !have_looped) {
1176 if (tf < _last_roll_or_reversal_location + offset) {
1177 return _last_roll_or_reversal_location;
1185 } else if (_transport_speed < 0.0f) {
1187 /* XXX wot? no backward looping? */
1189 if (tf > _last_roll_or_reversal_location - offset) {
1190 return _last_roll_or_reversal_location;
1202 Session::set_frame_rate (framecnt_t frames_per_second)
1204 /** \fn void Session::set_frame_size(framecnt_t)
1205 the AudioEngine object that calls this guarantees
1206 that it will not be called while we are also in
1207 ::process(). Its fine to do things that block
1211 _base_frame_rate = frames_per_second;
1215 Automatable::set_automation_interval (ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
1219 // XXX we need some equivalent to this, somehow
1220 // SndFileSource::setup_standard_crossfades (frames_per_second);
1224 /* XXX need to reset/reinstantiate all LADSPA plugins */
1228 Session::set_block_size (pframes_t nframes)
1230 /* the AudioEngine guarantees
1231 that it will not be called while we are also in
1232 ::process(). It is therefore fine to do things that block
1237 current_block_size = nframes;
1241 boost::shared_ptr<RouteList> r = routes.reader ();
1243 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1244 (*i)->set_block_size (nframes);
1247 boost::shared_ptr<RouteList> rl = routes.reader ();
1248 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1249 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1251 tr->set_block_size (nframes);
1255 set_worst_io_latencies ();
1259 struct RouteSorter {
1260 /** @return true to run r1 before r2, otherwise false */
1261 bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
1262 if (r2->feeds (r1)) {
1263 /* r1 fed by r2; run r2 early */
1265 } else if (r1->feeds (r2)) {
1266 /* r2 fed by r1; run r1 early */
1269 if (r1->not_fed ()) {
1270 if (r2->not_fed ()) {
1271 /* no ardour-based connections inbound to either route. just use signal order */
1272 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1274 /* r2 has connections, r1 does not; run r1 early */
1278 if (r2->not_fed()) {
1279 /* r1 has connections, r2 does not; run r2 early */
1282 /* both r1 and r2 have connections, but not to each other. just use signal order */
1283 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1291 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1293 boost::shared_ptr<Route> r2;
1295 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1296 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1300 /* make a copy of the existing list of routes that feed r1 */
1302 Route::FedBy existing (r1->fed_by());
1304 /* for each route that feeds r1, recurse, marking it as feeding
1308 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1309 if (!(r2 = i->r.lock ())) {
1310 /* (*i) went away, ignore it */
1314 /* r2 is a route that feeds r1 which somehow feeds base. mark
1315 base as being fed by r2
1318 rbase->add_fed_by (r2, i->sends_only);
1322 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1326 if (r1->feeds (r2) && r2->feeds (r1)) {
1330 /* now recurse, so that we can mark base as being fed by
1331 all routes that feed r2
1334 trace_terminal (r2, rbase);
1341 Session::resort_routes ()
1343 /* don't do anything here with signals emitted
1344 by Routes while we are being destroyed.
1347 if (_state_of_the_state & Deletion) {
1352 RCUWriter<RouteList> writer (routes);
1353 boost::shared_ptr<RouteList> r = writer.get_copy ();
1354 resort_routes_using (r);
1355 /* writer goes out of scope and forces update */
1358 //route_graph->dump(1);
1361 boost::shared_ptr<RouteList> rl = routes.reader ();
1362 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1363 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1365 const Route::FedBy& fb ((*i)->fed_by());
1367 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1368 boost::shared_ptr<Route> sf = f->r.lock();
1370 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1378 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1380 RouteList::iterator i, j;
1382 for (i = r->begin(); i != r->end(); ++i) {
1384 (*i)->clear_fed_by ();
1386 for (j = r->begin(); j != r->end(); ++j) {
1388 /* although routes can feed themselves, it will
1389 cause an endless recursive descent if we
1390 detect it. so don't bother checking for
1398 bool via_sends_only;
1400 if ((*j)->direct_feeds (*i, &via_sends_only)) {
1401 (*i)->add_fed_by (*j, via_sends_only);
1406 for (i = r->begin(); i != r->end(); ++i) {
1407 trace_terminal (*i, *i);
1413 route_graph->rechain (r);
1416 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1417 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1418 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1419 (*i)->name(), (*i)->order_key ("signal")));
1425 /** Find a route name starting with \a base, maybe followed by the
1426 * lowest \a id. \a id will always be added if \a definitely_add_number
1427 * is true on entry; otherwise it will only be added if required
1428 * to make the name unique.
1430 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1431 * The available route name with the lowest ID will be used, and \a id
1432 * will be set to the ID.
1434 * \return false if a route name could not be found, and \a track_name
1435 * and \a id do not reflect a free route name.
1438 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1440 if (!definitely_add_number && route_by_name (base) == 0) {
1441 /* juse use the base */
1442 snprintf (name, name_len, "%s", base.c_str());
1447 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1449 if (route_by_name (name) == 0) {
1455 } while (id < (UINT_MAX-1));
1460 /** Count the total ins and outs of all non-hidden routes in the session and return them in in and out */
1462 Session::count_existing_route_channels (ChanCount& in, ChanCount& out)
1464 in = ChanCount::ZERO;
1465 out = ChanCount::ZERO;
1466 boost::shared_ptr<RouteList> r = routes.reader ();
1467 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1468 if (!(*i)->is_hidden()) {
1469 in += (*i)->n_inputs();
1470 out += (*i)->n_outputs();
1475 /** Caller must not hold process lock
1476 * @param name_template string to use for the start of the name, or "" to use "Midi".
1478 list<boost::shared_ptr<MidiTrack> >
1479 Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1481 char track_name[32];
1482 uint32_t track_id = 0;
1483 ChanCount existing_inputs;
1484 ChanCount existing_outputs;
1486 RouteList new_routes;
1487 list<boost::shared_ptr<MidiTrack> > ret;
1488 uint32_t control_id;
1490 count_existing_route_channels (existing_inputs, existing_outputs);
1492 control_id = ntracks() + nbusses();
1494 bool const use_number = (how_many != 1);
1497 if (!find_route_name (name_template.empty() ? _("Midi") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1498 error << "cannot find name for new midi track" << endmsg;
1502 boost::shared_ptr<MidiTrack> track;
1505 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1507 if (track->init ()) {
1511 track->use_new_diskstream();
1513 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1514 boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1517 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1518 if (track->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
1519 error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
1523 if (track->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
1524 error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
1529 auto_connect_route (track.get(), existing_inputs, existing_outputs);
1531 track->non_realtime_input_change();
1534 route_group->add (track);
1537 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1538 track->set_remote_control_id (control_id);
1540 new_routes.push_back (track);
1541 ret.push_back (track);
1544 catch (failed_constructor &err) {
1545 error << _("Session: could not create new midi track.") << endmsg;
1549 catch (AudioEngine::PortRegistrationFailure& pfe) {
1551 error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
1559 if (!new_routes.empty()) {
1560 add_routes (new_routes, false);
1561 save_state (_current_snapshot_name);
1567 /** Caller must hold process lock.
1568 * @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1569 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1570 * @param output_start As \a input_start, but for outputs.
1573 Session::auto_connect_route (
1574 Route* route, ChanCount& existing_inputs, ChanCount& existing_outputs, bool connect_inputs, ChanCount input_start, ChanCount output_start
1577 /* If both inputs and outputs are auto-connected to physical ports,
1578 use the max of input and output offsets to ensure auto-connected
1579 port numbers always match up (e.g. the first audio input and the
1580 first audio output of the route will have the same physical
1581 port number). Otherwise just use the lowest input or output
1585 const bool in_out_physical =
1586 (Config->get_input_auto_connect() & AutoConnectPhysical)
1587 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1590 const ChanCount in_offset = in_out_physical
1591 ? ChanCount::max(existing_inputs, existing_outputs)
1594 const ChanCount out_offset = in_out_physical
1595 ? ChanCount::max(existing_inputs, existing_outputs)
1598 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1599 vector<string> physinputs;
1600 vector<string> physoutputs;
1602 _engine.get_physical_outputs (*t, physoutputs);
1603 _engine.get_physical_inputs (*t, physinputs);
1605 if (!physinputs.empty() && connect_inputs) {
1606 uint32_t nphysical_in = physinputs.size();
1607 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1610 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1611 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1614 if (!port.empty() && route->input()->connect (
1615 route->input()->ports().port(*t, i), port, this)) {
1621 if (!physoutputs.empty()) {
1622 uint32_t nphysical_out = physoutputs.size();
1623 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1626 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1627 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1628 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1629 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1630 port = _master_out->input()->ports().port(*t,
1631 i % _master_out->input()->n_ports().get(*t))->name();
1635 if (!port.empty() && route->output()->connect (
1636 route->output()->ports().port(*t, i), port, this)) {
1643 existing_inputs += route->n_inputs();
1644 existing_outputs += route->n_outputs();
1647 /** Caller must not hold process lock
1648 * @param name_template string to use for the start of the name, or "" to use "Audio".
1650 list< boost::shared_ptr<AudioTrack> >
1651 Session::new_audio_track (
1652 int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template
1655 char track_name[32];
1656 uint32_t track_id = 0;
1657 ChanCount existing_inputs;
1658 ChanCount existing_outputs;
1660 RouteList new_routes;
1661 list<boost::shared_ptr<AudioTrack> > ret;
1662 uint32_t control_id;
1664 count_existing_route_channels (existing_inputs, existing_outputs);
1666 control_id = ntracks() + nbusses() + 1;
1668 bool const use_number = (how_many != 1);
1671 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1672 error << "cannot find name for new audio track" << endmsg;
1676 boost::shared_ptr<AudioTrack> track;
1679 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
1681 if (track->init ()) {
1685 track->use_new_diskstream();
1687 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1688 boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1691 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1693 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1694 error << string_compose (
1695 _("cannot configure %1 in/%2 out configuration for new audio track"),
1696 input_channels, output_channels)
1701 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1702 error << string_compose (
1703 _("cannot configure %1 in/%2 out configuration for new audio track"),
1704 input_channels, output_channels)
1709 auto_connect_route (track.get(), existing_inputs, existing_outputs);
1713 route_group->add (track);
1716 track->non_realtime_input_change();
1718 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1719 track->set_remote_control_id (control_id);
1722 new_routes.push_back (track);
1723 ret.push_back (track);
1726 catch (failed_constructor &err) {
1727 error << _("Session: could not create new audio track.") << endmsg;
1731 catch (AudioEngine::PortRegistrationFailure& pfe) {
1733 error << pfe.what() << endmsg;
1741 if (!new_routes.empty()) {
1742 add_routes (new_routes, true);
1749 Session::set_remote_control_ids ()
1751 RemoteModel m = Config->get_remote_model();
1752 bool emit_signal = false;
1754 boost::shared_ptr<RouteList> r = routes.reader ();
1756 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1757 if (MixerOrdered == m) {
1758 int32_t order = (*i)->order_key(N_("signal"));
1759 (*i)->set_remote_control_id (order+1, false);
1761 } else if (EditorOrdered == m) {
1762 int32_t order = (*i)->order_key(N_("editor"));
1763 (*i)->set_remote_control_id (order+1, false);
1765 } else if (UserOrdered == m) {
1766 //do nothing ... only changes to remote id's are initiated by user
1771 Route::RemoteControlIDChange();
1775 /** Caller must not hold process lock.
1776 * @param name_template string to use for the start of the name, or "" to use "Bus".
1779 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
1782 uint32_t bus_id = 0;
1783 ChanCount existing_inputs;
1784 ChanCount existing_outputs;
1787 uint32_t control_id;
1789 count_existing_route_channels (existing_inputs, existing_outputs);
1791 control_id = ntracks() + nbusses() + 1;
1793 bool const use_number = (how_many != 1);
1795 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
1796 error << "cannot find name for new audio bus" << endmsg;
1801 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
1807 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1808 boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
1811 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1813 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1814 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1815 input_channels, output_channels)
1821 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1822 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1823 input_channels, output_channels)
1828 auto_connect_route (bus.get(), existing_inputs, existing_outputs, false);
1832 route_group->add (bus);
1834 bus->set_remote_control_id (control_id);
1837 bus->add_internal_return ();
1839 ret.push_back (bus);
1843 catch (failed_constructor &err) {
1844 error << _("Session: could not create new audio route.") << endmsg;
1848 catch (AudioEngine::PortRegistrationFailure& pfe) {
1849 error << pfe.what() << endmsg;
1859 add_routes (ret, true);
1867 Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
1871 uint32_t control_id;
1873 uint32_t number = 0;
1875 if (!tree.read (template_path.c_str())) {
1879 XMLNode* node = tree.root();
1881 control_id = ntracks() + nbusses() + 1;
1885 XMLNode node_copy (*node); // make a copy so we can change the name if we need to
1887 std::string node_name = IO::name_from_state (*node_copy.children().front());
1889 /* generate a new name by adding a number to the end of the template name */
1890 if (!find_route_name (node_name.c_str(), ++number, name, sizeof(name), true)) {
1891 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
1895 /* set IO children to use the new name */
1896 XMLNodeList const & children = node_copy.children ();
1897 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
1898 if ((*i)->name() == IO::state_node_name) {
1899 IO::set_name_in_state (**i, name);
1903 Track::zero_diskstream_id_in_xml (node_copy);
1906 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
1909 error << _("Session: cannot create track/bus from template description") << endmsg;
1913 if (boost::dynamic_pointer_cast<Track>(route)) {
1914 /* force input/output change signals so that the new diskstream
1915 picks up the configuration of the route. During session
1916 loading this normally happens in a different way.
1919 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1921 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
1922 change.after = route->input()->n_ports();
1923 route->input()->changed (change, this);
1924 change.after = route->output()->n_ports();
1925 route->output()->changed (change, this);
1928 route->set_remote_control_id (control_id);
1931 ret.push_back (route);
1934 catch (failed_constructor &err) {
1935 error << _("Session: could not create new route from template") << endmsg;
1939 catch (AudioEngine::PortRegistrationFailure& pfe) {
1940 error << pfe.what() << endmsg;
1949 add_routes (ret, true);
1956 Session::add_routes (RouteList& new_routes, bool save)
1959 RCUWriter<RouteList> writer (routes);
1960 boost::shared_ptr<RouteList> r = writer.get_copy ();
1961 r->insert (r->end(), new_routes.begin(), new_routes.end());
1964 /* if there is no control out and we're not in the middle of loading,
1965 resort the graph here. if there is a control out, we will resort
1966 toward the end of this method. if we are in the middle of loading,
1967 we will resort when done.
1970 if (!_monitor_out && IO::connecting_legal) {
1971 resort_routes_using (r);
1975 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
1977 boost::weak_ptr<Route> wpr (*x);
1978 boost::shared_ptr<Route> r (*x);
1980 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
1981 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
1982 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
1983 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
1984 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
1985 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
1986 r->order_key_changed.connect_same_thread (*this, boost::bind (&Session::route_order_key_changed, this));
1988 if (r->is_master()) {
1992 if (r->is_monitor()) {
1996 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
1998 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
1999 track_playlist_changed (boost::weak_ptr<Track> (tr));
2000 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2002 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2004 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2009 if (_monitor_out && IO::connecting_legal) {
2011 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2012 if ((*x)->is_monitor()) {
2014 } else if ((*x)->is_master()) {
2017 (*x)->listen_via_monitor ();
2027 save_state (_current_snapshot_name);
2030 RouteAdded (new_routes); /* EMIT SIGNAL */
2031 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
2035 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2037 boost::shared_ptr<RouteList> r = routes.reader ();
2038 boost::shared_ptr<Send> s;
2040 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2041 if ((s = (*i)->internal_send_for (dest)) != 0) {
2042 s->amp()->gain_control()->set_value (0.0);
2048 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2050 boost::shared_ptr<RouteList> r = routes.reader ();
2051 boost::shared_ptr<Send> s;
2053 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2054 if ((s = (*i)->internal_send_for (dest)) != 0) {
2055 s->amp()->gain_control()->set_value (1.0);
2061 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2063 boost::shared_ptr<RouteList> r = routes.reader ();
2064 boost::shared_ptr<Send> s;
2066 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2067 if ((s = (*i)->internal_send_for (dest)) != 0) {
2068 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2073 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2075 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2077 boost::shared_ptr<RouteList> r = routes.reader ();
2078 boost::shared_ptr<RouteList> t (new RouteList);
2080 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2081 if (include_buses || boost::dynamic_pointer_cast<Track>(*i)) {
2086 add_internal_sends (dest, p, t);
2090 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2092 if (dest->is_monitor() || dest->is_master()) {
2096 if (!dest->internal_return()) {
2097 dest->add_internal_return();
2100 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2102 if ((*i)->is_monitor() || (*i)->is_master() || (*i) == dest) {
2106 (*i)->listen_via (dest, p);
2113 Session::remove_route (boost::shared_ptr<Route> route)
2115 if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
2119 route->set_solo (false, this);
2122 RCUWriter<RouteList> writer (routes);
2123 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2127 /* deleting the master out seems like a dumb
2128 idea, but its more of a UI policy issue
2132 if (route == _master_out) {
2133 _master_out = boost::shared_ptr<Route> ();
2136 if (route == _monitor_out) {
2138 /* cancel control outs for all routes */
2140 for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2141 (*r)->drop_listen (_monitor_out);
2144 _monitor_out.reset ();
2147 /* writer goes out of scope, forces route list update */
2150 update_route_solo_state ();
2152 // We need to disconnect the route's inputs and outputs
2154 route->input()->disconnect (0);
2155 route->output()->disconnect (0);
2157 /* if the route had internal sends sending to it, remove them */
2158 if (route->internal_return()) {
2160 boost::shared_ptr<RouteList> r = routes.reader ();
2161 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2162 boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2164 (*i)->remove_processor (s);
2169 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2170 if (mt && mt->step_editing()) {
2171 if (_step_editors > 0) {
2176 update_latency_compensation (false, false);
2179 /* Re-sort routes to remove the graph's current references to the one that is
2180 * going away, then flush old references out of the graph.
2184 route_graph->clear_other_chain ();
2186 /* get rid of it from the dead wood collection in the route list manager */
2188 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2192 /* try to cause everyone to drop their references */
2194 route->drop_references ();
2196 sync_order_keys (N_("session"));
2198 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2200 /* save the new state of the world */
2202 if (save_state (_current_snapshot_name)) {
2203 save_history (_current_snapshot_name);
2208 Session::route_mute_changed (void* /*src*/)
2214 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2216 boost::shared_ptr<Route> route = wpr.lock();
2218 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2222 if (route->listening_via_monitor ()) {
2224 if (Config->get_exclusive_solo()) {
2225 /* new listen: disable all other listen */
2226 boost::shared_ptr<RouteList> r = routes.reader ();
2227 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2228 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2231 (*i)->set_listen (false, this);
2237 } else if (_listen_cnt > 0) {
2242 update_route_solo_state ();
2245 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2247 boost::shared_ptr<Route> route = wpr.lock ();
2250 /* should not happen */
2251 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2255 bool send_changed = false;
2257 if (route->solo_isolated()) {
2258 if (_solo_isolated_cnt == 0) {
2259 send_changed = true;
2261 _solo_isolated_cnt++;
2262 } else if (_solo_isolated_cnt > 0) {
2263 _solo_isolated_cnt--;
2264 if (_solo_isolated_cnt == 0) {
2265 send_changed = true;
2270 IsolatedChanged (); /* EMIT SIGNAL */
2275 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2277 if (!self_solo_change) {
2278 // session doesn't care about changes to soloed-by-others
2282 if (solo_update_disabled) {
2287 boost::shared_ptr<Route> route = wpr.lock ();
2290 /* should not happen */
2291 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2295 boost::shared_ptr<RouteList> r = routes.reader ();
2298 if (route->self_soloed()) {
2304 if (delta == 1 && Config->get_exclusive_solo()) {
2305 /* new solo: disable all other solos */
2306 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2307 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2310 (*i)->set_solo (false, this);
2314 solo_update_disabled = true;
2316 RouteList uninvolved;
2318 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2319 bool via_sends_only;
2320 bool in_signal_flow;
2322 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2326 in_signal_flow = false;
2328 if ((*i)->feeds (route, &via_sends_only)) {
2329 if (!via_sends_only) {
2330 if (!route->soloed_by_others_upstream()) {
2331 (*i)->mod_solo_by_others_downstream (delta);
2333 in_signal_flow = true;
2337 if (route->feeds (*i, &via_sends_only)) {
2338 (*i)->mod_solo_by_others_upstream (delta);
2339 in_signal_flow = true;
2342 if (!in_signal_flow) {
2343 uninvolved.push_back (*i);
2347 solo_update_disabled = false;
2348 update_route_solo_state (r);
2350 /* now notify that the mute state of the routes not involved in the signal
2351 pathway of the just-solo-changed route may have altered.
2354 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2355 (*i)->mute_changed (this);
2358 SoloChanged (); /* EMIT SIGNAL */
2363 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2365 /* now figure out if anything that matters is soloed (or is "listening")*/
2367 bool something_soloed = false;
2368 uint32_t listeners = 0;
2369 uint32_t isolated = 0;
2372 r = routes.reader();
2375 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2376 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2377 something_soloed = true;
2380 if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
2381 if (Config->get_solo_control_is_listen_control()) {
2384 (*i)->set_listen (false, this);
2388 if ((*i)->solo_isolated()) {
2393 if (something_soloed != _non_soloed_outs_muted) {
2394 _non_soloed_outs_muted = something_soloed;
2395 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2398 _listen_cnt = listeners;
2400 if (isolated != _solo_isolated_cnt) {
2401 _solo_isolated_cnt = isolated;
2402 IsolatedChanged (); /* EMIT SIGNAL */
2406 boost::shared_ptr<RouteList>
2407 Session::get_routes_with_internal_returns() const
2409 boost::shared_ptr<RouteList> r = routes.reader ();
2410 boost::shared_ptr<RouteList> rl (new RouteList);
2412 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2413 if ((*i)->internal_return ()) {
2421 Session::io_name_is_legal (const std::string& name)
2423 boost::shared_ptr<RouteList> r = routes.reader ();
2425 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2426 if ((*i)->name() == name) {
2430 if ((*i)->has_io_processor_named (name)) {
2438 boost::shared_ptr<Route>
2439 Session::route_by_name (string name)
2441 boost::shared_ptr<RouteList> r = routes.reader ();
2443 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2444 if ((*i)->name() == name) {
2449 return boost::shared_ptr<Route> ((Route*) 0);
2452 boost::shared_ptr<Route>
2453 Session::route_by_id (PBD::ID id)
2455 boost::shared_ptr<RouteList> r = routes.reader ();
2457 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2458 if ((*i)->id() == id) {
2463 return boost::shared_ptr<Route> ((Route*) 0);
2466 boost::shared_ptr<Route>
2467 Session::route_by_remote_id (uint32_t id)
2469 boost::shared_ptr<RouteList> r = routes.reader ();
2471 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2472 if ((*i)->remote_control_id() == id) {
2477 return boost::shared_ptr<Route> ((Route*) 0);
2481 Session::playlist_region_added (boost::weak_ptr<Region> w)
2483 boost::shared_ptr<Region> r = w.lock ();
2488 /* These are the operations that are currently in progress... */
2489 list<GQuark> curr = _current_trans_quarks;
2492 /* ...and these are the operations during which we want to update
2493 the session range location markers.
2496 ops.push_back (Operations::capture);
2497 ops.push_back (Operations::paste);
2498 ops.push_back (Operations::duplicate_region);
2499 ops.push_back (Operations::insert_file);
2500 ops.push_back (Operations::insert_region);
2501 ops.push_back (Operations::drag_region_brush);
2502 ops.push_back (Operations::region_drag);
2503 ops.push_back (Operations::selection_grab);
2504 ops.push_back (Operations::region_fill);
2505 ops.push_back (Operations::fill_selection);
2506 ops.push_back (Operations::create_region);
2509 /* See if any of the current operations match the ones that we want */
2511 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2513 /* If so, update the session range markers */
2515 maybe_update_session_range (r->position (), r->last_frame ());
2519 /** Update the session range markers if a is before the current start or
2520 * b is after the current end.
2523 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2525 if (_state_of_the_state & Loading) {
2529 if (_session_range_location == 0) {
2531 add_session_range_location (a, b);
2535 if (a < _session_range_location->start()) {
2536 _session_range_location->set_start (a);
2539 if (b > _session_range_location->end()) {
2540 _session_range_location->set_end (b);
2546 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2548 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2549 maybe_update_session_range (i->to, i->to + i->length);
2554 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2556 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2557 maybe_update_session_range (i->from, i->to);
2561 /* Region management */
2563 boost::shared_ptr<Region>
2564 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2566 const RegionFactory::RegionMap& regions (RegionFactory::regions());
2567 RegionFactory::RegionMap::const_iterator i;
2568 boost::shared_ptr<Region> region;
2570 Glib::Mutex::Lock lm (region_lock);
2572 for (i = regions.begin(); i != regions.end(); ++i) {
2576 if (region->whole_file()) {
2578 if (child->source_equivalent (region)) {
2584 return boost::shared_ptr<Region> ();
2588 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2590 set<boost::shared_ptr<Region> > relevant_regions;
2592 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2593 RegionFactory::get_regions_using_source (*s, relevant_regions);
2596 cerr << "There are " << relevant_regions.size() << " using " << srcs.size() << " sources" << endl;
2598 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2599 set<boost::shared_ptr<Region> >::iterator tmp;
2604 cerr << "Cleanup " << (*r)->name() << " UC = " << (*r).use_count() << endl;
2606 playlists->destroy_region (*r);
2607 RegionFactory::map_remove (*r);
2609 (*r)->drop_sources ();
2610 (*r)->drop_references ();
2612 cerr << "\tdone UC = " << (*r).use_count() << endl;
2614 relevant_regions.erase (r);
2619 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2622 Glib::Mutex::Lock ls (source_lock);
2623 /* remove from the main source list */
2624 sources.erase ((*s)->id());
2627 (*s)->mark_for_remove ();
2628 (*s)->drop_references ();
2637 Session::remove_last_capture ()
2639 list<boost::shared_ptr<Source> > srcs;
2641 boost::shared_ptr<RouteList> rl = routes.reader ();
2642 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2643 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2648 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
2651 srcs.insert (srcs.end(), l.begin(), l.end());
2656 destroy_sources (srcs);
2658 save_state (_current_snapshot_name);
2663 /* Source Management */
2666 Session::add_source (boost::shared_ptr<Source> source)
2668 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
2669 pair<SourceMap::iterator,bool> result;
2671 entry.first = source->id();
2672 entry.second = source;
2675 Glib::Mutex::Lock lm (source_lock);
2676 result = sources.insert (entry);
2679 if (result.second) {
2681 /* yay, new source */
2685 boost::shared_ptr<AudioFileSource> afs;
2687 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2688 if (Config->get_auto_analyse_audio()) {
2689 Analyser::queue_source_for_analysis (source, false);
2693 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
2698 Session::remove_source (boost::weak_ptr<Source> src)
2700 SourceMap::iterator i;
2701 boost::shared_ptr<Source> source = src.lock();
2708 Glib::Mutex::Lock lm (source_lock);
2710 if ((i = sources.find (source->id())) != sources.end()) {
2711 cerr << "Removing source " << source->name() << endl;
2716 if (!_state_of_the_state & InCleanup) {
2718 /* save state so we don't end up with a session file
2719 referring to non-existent sources.
2722 save_state (_current_snapshot_name);
2726 boost::shared_ptr<Source>
2727 Session::source_by_id (const PBD::ID& id)
2729 Glib::Mutex::Lock lm (source_lock);
2730 SourceMap::iterator i;
2731 boost::shared_ptr<Source> source;
2733 if ((i = sources.find (id)) != sources.end()) {
2740 boost::shared_ptr<Source>
2741 Session::source_by_path_and_channel (const string& path, uint16_t chn)
2743 Glib::Mutex::Lock lm (source_lock);
2745 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2746 boost::shared_ptr<AudioFileSource> afs
2747 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2749 if (afs && afs->path() == path && chn == afs->channel()) {
2753 return boost::shared_ptr<Source>();
2757 Session::count_sources_by_origin (const string& path)
2760 Glib::Mutex::Lock lm (source_lock);
2762 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2763 boost::shared_ptr<FileSource> fs
2764 = boost::dynamic_pointer_cast<FileSource>(i->second);
2766 if (fs && fs->origin() == path) {
2776 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
2779 string old_basename = PBD::basename_nosuffix (oldname);
2780 string new_legalized = legalize_for_path (newname);
2782 /* note: we know (or assume) the old path is already valid */
2786 /* destructive file sources have a name of the form:
2788 /path/to/Tnnnn-NAME(%[LR])?.wav
2790 the task here is to replace NAME with the new name.
2795 string::size_type dash;
2797 dir = Glib::path_get_dirname (path);
2798 path = Glib::path_get_basename (path);
2800 /* '-' is not a legal character for the NAME part of the path */
2802 if ((dash = path.find_last_of ('-')) == string::npos) {
2806 prefix = path.substr (0, dash);
2810 path += new_legalized;
2811 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
2812 path = Glib::build_filename (dir, path);
2816 /* non-destructive file sources have a name of the form:
2818 /path/to/NAME-nnnnn(%[LR])?.ext
2820 the task here is to replace NAME with the new name.
2825 string::size_type dash;
2826 string::size_type postfix;
2828 dir = Glib::path_get_dirname (path);
2829 path = Glib::path_get_basename (path);
2831 /* '-' is not a legal character for the NAME part of the path */
2833 if ((dash = path.find_last_of ('-')) == string::npos) {
2837 suffix = path.substr (dash+1);
2839 // Suffix is now everything after the dash. Now we need to eliminate
2840 // the nnnnn part, which is done by either finding a '%' or a '.'
2842 postfix = suffix.find_last_of ("%");
2843 if (postfix == string::npos) {
2844 postfix = suffix.find_last_of ('.');
2847 if (postfix != string::npos) {
2848 suffix = suffix.substr (postfix);
2850 error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
2854 const uint32_t limit = 10000;
2855 char buf[PATH_MAX+1];
2857 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
2859 snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
2861 if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
2862 path = Glib::build_filename (dir, buf);
2870 fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
2879 /** Return the full path (in some session directory) for a new within-session source.
2880 * \a name must be a session-unique name that does not contain slashes
2881 * (e.g. as returned by new_*_source_name)
2884 Session::new_source_path_from_name (DataType type, const string& name, bool as_stub)
2886 assert(name.find("/") == string::npos);
2888 SessionDirectory sdir(get_best_session_directory_for_new_source());
2891 if (type == DataType::AUDIO) {
2892 p = (as_stub ? sdir.sound_stub_path() : sdir.sound_path());
2893 } else if (type == DataType::MIDI) {
2894 p = (as_stub ? sdir.midi_stub_path() : sdir.midi_path());
2896 error << "Unknown source type, unable to create file path" << endmsg;
2901 return p.to_string();
2905 Session::peak_path (string base) const
2907 sys::path peakfile_path(_session_dir->peak_path());
2908 peakfile_path /= base + peakfile_suffix;
2909 return peakfile_path.to_string();
2912 /** Return a unique name based on \a base for a new internal audio source */
2914 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
2917 char buf[PATH_MAX+1];
2918 const uint32_t limit = 10000;
2920 string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
2923 legalized = legalize_for_path (base);
2925 // Find a "version" of the base name that doesn't exist in any of the possible directories.
2926 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
2928 vector<space_and_path>::iterator i;
2929 uint32_t existing = 0;
2931 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
2936 snprintf (buf, sizeof(buf), "T%04d-%s%s",
2937 cnt, legalized.c_str(), ext.c_str());
2938 } else if (nchan == 2) {
2940 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
2941 cnt, legalized.c_str(), ext.c_str());
2943 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
2944 cnt, legalized.c_str(), ext.c_str());
2946 } else if (nchan < 26) {
2947 snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
2948 cnt, legalized.c_str(), 'a' + chan, ext.c_str());
2950 snprintf (buf, sizeof(buf), "T%04d-%s%s",
2951 cnt, legalized.c_str(), ext.c_str());
2957 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
2958 } else if (nchan == 2) {
2960 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
2962 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
2964 } else if (nchan < 26) {
2965 snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
2967 snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
2971 SessionDirectory sdir((*i).path);
2973 string spath = sdir.sound_path().to_string();
2974 string spath_stubs = sdir.sound_stub_path().to_string();
2976 /* note that we search *without* the extension so that
2977 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
2978 in the event that this new name is required for
2979 a file format change.
2982 if (matching_unsuffixed_filename_exists_in (spath, buf) ||
2983 matching_unsuffixed_filename_exists_in (spath_stubs, buf)) {
2989 if (existing == 0) {
2994 error << string_compose(
2995 _("There are already %1 recordings for %2, which I consider too many."),
2996 limit, base) << endmsg;
2998 throw failed_constructor();
3002 return Glib::path_get_basename (buf);
3005 /** Create a new within-session audio source */
3006 boost::shared_ptr<AudioFileSource>
3007 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive, bool as_stub)
3009 const string name = new_audio_source_name (n, n_chans, chan, destructive);
3010 const string path = new_source_path_from_name(DataType::AUDIO, name, as_stub);
3012 return boost::dynamic_pointer_cast<AudioFileSource> (
3013 SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
3016 /** Return a unique name based on \a base for a new internal MIDI source */
3018 Session::new_midi_source_name (const string& base)
3021 char buf[PATH_MAX+1];
3022 const uint32_t limit = 10000;
3026 legalized = legalize_for_path (base);
3028 // Find a "version" of the file name that doesn't exist in any of the possible directories.
3029 for (cnt = 1; cnt <= limit; ++cnt) {
3031 vector<space_and_path>::iterator i;
3032 uint32_t existing = 0;
3034 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3036 SessionDirectory sdir((*i).path);
3038 sys::path p = sdir.midi_path();
3041 snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
3043 if (sys::exists (buf)) {
3048 if (existing == 0) {
3053 error << string_compose(
3054 _("There are already %1 recordings for %2, which I consider too many."),
3055 limit, base) << endmsg;
3057 throw failed_constructor();
3061 return Glib::path_get_basename(buf);
3065 /** Create a new within-session MIDI source */
3066 boost::shared_ptr<MidiSource>
3067 Session::create_midi_source_for_session (Track* track, string const & n, bool as_stub)
3069 /* try to use the existing write source for the track, to keep numbering sane
3073 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3077 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3080 assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3081 return boost::dynamic_pointer_cast<MidiSource> (l.front());
3085 const string name = new_midi_source_name (n);
3086 const string path = new_source_path_from_name (DataType::MIDI, name, as_stub);
3088 return boost::dynamic_pointer_cast<SMFSource> (
3089 SourceFactory::createWritable (
3090 DataType::MIDI, *this, path, string(), false, frame_rate()));
3095 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3097 if (playlist->hidden()) {
3101 playlists->add (playlist);
3104 playlist->release();
3111 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3113 if (_state_of_the_state & Deletion) {
3117 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3123 playlists->remove (playlist);
3129 Session::set_audition (boost::shared_ptr<Region> r)
3131 pending_audition_region = r;
3132 add_post_transport_work (PostTransportAudition);
3133 _butler->schedule_transport_work ();
3137 Session::audition_playlist ()
3139 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3140 ev->region.reset ();
3145 Session::non_realtime_set_audition ()
3147 if (!pending_audition_region) {
3148 auditioner->audition_current_playlist ();
3150 auditioner->audition_region (pending_audition_region);
3151 pending_audition_region.reset ();
3153 AuditionActive (true); /* EMIT SIGNAL */
3157 Session::audition_region (boost::shared_ptr<Region> r)
3159 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3165 Session::cancel_audition ()
3167 if (auditioner->auditioning()) {
3168 auditioner->cancel_audition ();
3169 AuditionActive (false); /* EMIT SIGNAL */
3174 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3176 if (a->is_monitor()) {
3179 if (b->is_monitor()) {
3182 return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3186 Session::is_auditioning () const
3188 /* can be called before we have an auditioner object */
3190 return auditioner->auditioning();
3197 Session::graph_reordered ()
3199 /* don't do this stuff if we are setting up connections
3200 from a set_state() call or creating new tracks. Ditto for deletion.
3203 if (_state_of_the_state & (InitialConnecting|Deletion)) {
3207 /* every track/bus asked for this to be handled but it was deferred because
3208 we were connecting. do it now.
3211 request_input_change_handling ();
3215 /* force all diskstreams to update their capture offset values to
3216 reflect any changes in latencies within the graph.
3219 boost::shared_ptr<RouteList> rl = routes.reader ();
3220 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3221 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3223 tr->set_capture_offset ();
3229 Session::available_capture_duration ()
3231 float sample_bytes_on_disk = 4.0; // keep gcc happy
3233 switch (config.get_native_file_data_format()) {
3235 sample_bytes_on_disk = 4.0;
3239 sample_bytes_on_disk = 3.0;
3243 sample_bytes_on_disk = 2.0;
3247 /* impossible, but keep some gcc versions happy */
3248 fatal << string_compose (_("programming error: %1"),
3249 X_("illegal native file data format"))
3254 double scale = 4096.0 / sample_bytes_on_disk;
3256 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3257 return max_framecnt;
3260 return (framecnt_t) floor (_total_free_4k_blocks * scale);
3264 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3267 RCUWriter<BundleList> writer (_bundles);
3268 boost::shared_ptr<BundleList> b = writer.get_copy ();
3269 b->push_back (bundle);
3272 BundleAdded (bundle); /* EMIT SIGNAL */
3278 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3280 bool removed = false;
3283 RCUWriter<BundleList> writer (_bundles);
3284 boost::shared_ptr<BundleList> b = writer.get_copy ();
3285 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3287 if (i != b->end()) {
3294 BundleRemoved (bundle); /* EMIT SIGNAL */
3300 boost::shared_ptr<Bundle>
3301 Session::bundle_by_name (string name) const
3303 boost::shared_ptr<BundleList> b = _bundles.reader ();
3305 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3306 if ((*i)->name() == name) {
3311 return boost::shared_ptr<Bundle> ();
3315 Session::tempo_map_changed (const PropertyChange&)
3319 playlists->update_after_tempo_map_change ();
3321 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3327 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3329 for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3330 (*i)->recompute_frames_from_bbt ();
3334 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3335 * the given count with the current block size.
3338 Session::ensure_buffers (ChanCount howmany)
3340 BufferManager::ensure_buffers (howmany);
3344 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3346 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3347 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3352 Session::next_insert_id ()
3354 /* this doesn't really loop forever. just think about it */
3357 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3358 if (!insert_bitset[n]) {
3359 insert_bitset[n] = true;
3365 /* none available, so resize and try again */
3367 insert_bitset.resize (insert_bitset.size() + 16, false);
3372 Session::next_send_id ()
3374 /* this doesn't really loop forever. just think about it */
3377 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3378 if (!send_bitset[n]) {
3379 send_bitset[n] = true;
3385 /* none available, so resize and try again */
3387 send_bitset.resize (send_bitset.size() + 16, false);
3392 Session::next_return_id ()
3394 /* this doesn't really loop forever. just think about it */
3397 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3398 if (!return_bitset[n]) {
3399 return_bitset[n] = true;
3405 /* none available, so resize and try again */
3407 return_bitset.resize (return_bitset.size() + 16, false);
3412 Session::mark_send_id (uint32_t id)
3414 if (id >= send_bitset.size()) {
3415 send_bitset.resize (id+16, false);
3417 if (send_bitset[id]) {
3418 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3420 send_bitset[id] = true;
3424 Session::mark_return_id (uint32_t id)
3426 if (id >= return_bitset.size()) {
3427 return_bitset.resize (id+16, false);
3429 if (return_bitset[id]) {
3430 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3432 return_bitset[id] = true;
3436 Session::mark_insert_id (uint32_t id)
3438 if (id >= insert_bitset.size()) {
3439 insert_bitset.resize (id+16, false);
3441 if (insert_bitset[id]) {
3442 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3444 insert_bitset[id] = true;
3448 Session::unmark_send_id (uint32_t id)
3450 if (id < send_bitset.size()) {
3451 send_bitset[id] = false;
3456 Session::unmark_return_id (uint32_t id)
3458 if (id < return_bitset.size()) {
3459 return_bitset[id] = false;
3464 Session::unmark_insert_id (uint32_t id)
3466 if (id < insert_bitset.size()) {
3467 insert_bitset[id] = false;
3472 /* Named Selection management */
3474 boost::shared_ptr<NamedSelection>
3475 Session::named_selection_by_name (string name)
3477 Glib::Mutex::Lock lm (named_selection_lock);
3478 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3479 if ((*i)->name == name) {
3483 return boost::shared_ptr<NamedSelection>();
3487 Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3490 Glib::Mutex::Lock lm (named_selection_lock);
3491 named_selections.insert (named_selections.begin(), named_selection);
3496 NamedSelectionAdded (); /* EMIT SIGNAL */
3500 Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3502 bool removed = false;
3505 Glib::Mutex::Lock lm (named_selection_lock);
3507 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3509 if (i != named_selections.end()) {
3510 named_selections.erase (i);
3517 NamedSelectionRemoved (); /* EMIT SIGNAL */
3522 Session::reset_native_file_format ()
3524 boost::shared_ptr<RouteList> rl = routes.reader ();
3525 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3526 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3528 /* don't save state as we do this, there's no point
3531 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3532 tr->reset_write_sources (false);
3533 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3539 Session::route_name_unique (string n) const
3541 boost::shared_ptr<RouteList> r = routes.reader ();
3543 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3544 if ((*i)->name() == n) {
3553 Session::route_name_internal (string n) const
3555 if (auditioner && auditioner->name() == n) {
3559 if (_click_io && _click_io->name() == n) {
3567 Session::freeze_all (InterThreadInfo& itt)
3569 boost::shared_ptr<RouteList> r = routes.reader ();
3571 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3573 boost::shared_ptr<Track> t;
3575 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3576 /* XXX this is wrong because itt.progress will keep returning to zero at the start
3586 boost::shared_ptr<Region>
3587 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3588 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3589 InterThreadInfo& itt, bool enable_processing)
3591 boost::shared_ptr<Region> result;
3592 boost::shared_ptr<Playlist> playlist;
3593 boost::shared_ptr<AudioFileSource> fsource;
3595 char buf[PATH_MAX+1];
3596 ChanCount diskstream_channels (track.n_channels());
3597 framepos_t position;
3598 framecnt_t this_chunk;
3601 SessionDirectory sdir(get_best_session_directory_for_new_source ());
3602 const string sound_dir = sdir.sound_path().to_string();
3603 framepos_t len = end - start;
3604 bool need_block_size_reset = false;
3606 ChanCount const max_proc = track.max_processor_streams ();
3609 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3610 end, start) << endmsg;
3614 const framecnt_t chunk_size = (256 * 1024)/4;
3616 // block all process callback handling
3618 block_processing ();
3620 /* call tree *MUST* hold route_lock */
3622 if ((playlist = track.playlist()) == 0) {
3626 /* external redirects will be a problem */
3628 if (track.has_external_redirects()) {
3632 ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3634 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3636 for (x = 0; x < 99999; ++x) {
3637 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());
3638 if (access (buf, F_OK) != 0) {
3644 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3649 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3650 SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
3653 catch (failed_constructor& err) {
3654 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3658 srcs.push_back (fsource);
3661 /* tell redirects that care that we are about to use a much larger blocksize */
3663 need_block_size_reset = true;
3664 track.set_block_size (chunk_size);
3666 /* XXX need to flush all redirects */
3671 /* create a set of reasonably-sized buffers */
3672 buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
3673 buffers.set_count (max_proc);
3675 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3676 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3678 afs->prepare_for_peakfile_writes ();
3681 while (to_do && !itt.cancel) {
3683 this_chunk = min (to_do, chunk_size);
3685 if (track.export_stuff (buffers, start, this_chunk, enable_processing)) {
3690 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3691 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3694 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
3700 start += this_chunk;
3701 to_do -= this_chunk;
3703 itt.progress = (float) (1.0 - ((double) to_do / len));
3712 xnow = localtime (&now);
3714 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3715 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3718 afs->update_header (position, *xnow, now);
3719 afs->flush_header ();
3723 /* construct a region to represent the bounced material */
3727 plist.add (Properties::start, 0);
3728 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
3729 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
3731 result = RegionFactory::create (srcs, plist);
3737 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3738 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3741 afs->mark_for_remove ();
3744 (*src)->drop_references ();
3748 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3749 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3752 afs->done_with_peakfile_writes ();
3757 if (need_block_size_reset) {
3758 track.set_block_size (get_block_size());
3761 unblock_processing ();
3767 Session::gain_automation_buffer() const
3769 return ProcessThread::gain_automation_buffer ();
3773 Session::pan_automation_buffer() const
3775 return ProcessThread::pan_automation_buffer ();
3779 Session::get_silent_buffers (ChanCount count)
3781 return ProcessThread::get_silent_buffers (count);
3783 assert(_silent_buffers->available() >= count);
3784 _silent_buffers->set_count(count);
3786 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3787 for (size_t i= 0; i < count.get(*t); ++i) {
3788 _silent_buffers->get(*t, i).clear();
3792 return *_silent_buffers;
3797 Session::get_scratch_buffers (ChanCount count)
3799 return ProcessThread::get_scratch_buffers (count);
3801 if (count != ChanCount::ZERO) {
3802 assert(_scratch_buffers->available() >= count);
3803 _scratch_buffers->set_count(count);
3805 _scratch_buffers->set_count (_scratch_buffers->available());
3808 return *_scratch_buffers;
3813 Session::get_mix_buffers (ChanCount count)
3815 return ProcessThread::get_mix_buffers (count);
3817 assert(_mix_buffers->available() >= count);
3818 _mix_buffers->set_count(count);
3819 return *_mix_buffers;
3824 Session::ntracks () const
3827 boost::shared_ptr<RouteList> r = routes.reader ();
3829 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3830 if (boost::dynamic_pointer_cast<Track> (*i)) {
3839 Session::nbusses () const
3842 boost::shared_ptr<RouteList> r = routes.reader ();
3844 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3845 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
3854 Session::add_automation_list(AutomationList *al)
3856 automation_lists[al->id()] = al;
3860 Session::sync_order_keys (std::string const & base)
3862 if (deletion_in_progress()) {
3866 if (!Config->get_sync_all_route_ordering()) {
3867 /* leave order keys as they are */
3871 boost::shared_ptr<RouteList> r = routes.reader ();
3873 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3874 (*i)->sync_order_keys (base);
3877 Route::SyncOrderKeys (base); // EMIT SIGNAL
3879 /* this might not do anything */
3881 set_remote_control_ids ();
3884 /** @return true if there is at least one record-enabled track, otherwise false */
3886 Session::have_rec_enabled_track () const
3888 return g_atomic_int_get (&_have_rec_enabled_track) == 1;
3891 /** Update the state of our rec-enabled tracks flag */
3893 Session::update_have_rec_enabled_track ()
3895 boost::shared_ptr<RouteList> rl = routes.reader ();
3896 RouteList::iterator i = rl->begin();
3897 while (i != rl->end ()) {
3899 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3900 if (tr && tr->record_enabled ()) {
3907 int const old = g_atomic_int_get (&_have_rec_enabled_track);
3909 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
3911 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
3912 RecordStateChanged (); /* EMIT SIGNAL */
3917 Session::listen_position_changed ()
3919 boost::shared_ptr<RouteList> r = routes.reader ();
3921 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3922 (*i)->listen_position_changed ();
3927 Session::solo_control_mode_changed ()
3929 /* cancel all solo or all listen when solo control mode changes */
3932 set_solo (get_routes(), false);
3933 } else if (listening()) {
3934 set_listen (get_routes(), false);
3938 /** Called when anything about any of our route groups changes (membership, state etc.) */
3940 Session::route_group_changed ()
3942 RouteGroupChanged (); /* EMIT SIGNAL */
3946 Session::get_available_sync_options () const
3948 vector<SyncSource> ret;
3950 ret.push_back (JACK);
3951 ret.push_back (MTC);
3952 ret.push_back (MIDIClock);
3957 boost::shared_ptr<RouteList>
3958 Session::get_routes_with_regions_at (framepos_t const p) const
3960 boost::shared_ptr<RouteList> r = routes.reader ();
3961 boost::shared_ptr<RouteList> rl (new RouteList);
3963 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3964 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3969 boost::shared_ptr<Playlist> pl = tr->playlist ();
3974 if (pl->has_region_at (p)) {
3983 Session::goto_end ()
3985 if (_session_range_location) {
3986 request_locate (_session_range_location->end(), false);
3988 request_locate (0, false);
3993 Session::goto_start ()
3995 if (_session_range_location) {
3996 request_locate (_session_range_location->start(), false);
3998 request_locate (0, false);
4003 Session::current_start_frame () const
4005 return _session_range_location ? _session_range_location->start() : 0;
4009 Session::current_end_frame () const
4011 return _session_range_location ? _session_range_location->end() : 0;
4015 Session::add_session_range_location (framepos_t start, framepos_t end)
4017 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4018 _locations->add (_session_range_location);
4021 /** Called when one of our routes' order keys has changed */
4023 Session::route_order_key_changed ()
4025 RouteOrderKeyChanged (); /* EMIT SIGNAL */
4029 Session::step_edit_status_change (bool yn)
4035 send = (_step_editors == 0);
4040 send = (_step_editors == 1);
4043 if (_step_editors > 0) {
4049 StepEditStatusChange (val);
4055 Session::start_time_changed (framepos_t old)
4057 /* Update the auto loop range to match the session range
4058 (unless the auto loop range has been changed by the user)
4061 Location* s = _locations->session_range_location ();
4066 Location* l = _locations->auto_loop_location ();
4068 if (l->start() == old) {
4069 l->set_start (s->start(), true);
4074 Session::end_time_changed (framepos_t old)
4076 /* Update the auto loop range to match the session range
4077 (unless the auto loop range has been changed by the user)
4080 Location* s = _locations->session_range_location ();
4085 Location* l = _locations->auto_loop_location ();
4087 if (l->end() == old) {
4088 l->set_end (s->end(), true);
4093 Session::source_search_path (DataType type) const
4097 if (session_dirs.size() == 1) {
4099 case DataType::AUDIO:
4100 search_path = _session_dir->sound_path().to_string();
4102 case DataType::MIDI:
4103 search_path = _session_dir->midi_path().to_string();
4107 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4108 SessionDirectory sdir (i->path);
4109 if (!search_path.empty()) {
4113 case DataType::AUDIO:
4114 search_path += sdir.sound_path().to_string();
4116 case DataType::MIDI:
4117 search_path += sdir.midi_path().to_string();
4123 /* now add user-specified locations
4126 vector<string> dirs;
4129 case DataType::AUDIO:
4130 split (config.get_audio_search_path (), dirs, ':');
4132 case DataType::MIDI:
4133 split (config.get_midi_search_path (), dirs, ':');
4137 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4147 Session::ensure_search_path_includes (const string& path, DataType type)
4150 vector<string> dirs;
4157 case DataType::AUDIO:
4158 search_path = config.get_audio_search_path ();
4160 case DataType::MIDI:
4161 search_path = config.get_midi_search_path ();
4165 split (search_path, dirs, ':');
4167 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4173 if (!search_path.empty()) {
4177 search_path += path;
4180 case DataType::AUDIO:
4181 config.set_audio_search_path (search_path);
4183 case DataType::MIDI:
4184 config.set_midi_search_path (search_path);
4189 boost::shared_ptr<Speakers>
4190 Session::get_speakers()
4196 Session::unknown_processors () const
4200 boost::shared_ptr<RouteList> r = routes.reader ();
4201 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4202 list<string> t = (*i)->unknown_processors ();
4203 copy (t.begin(), t.end(), back_inserter (p));
4212 #ifdef HAVE_JACK_NEW_LATENCY
4214 Session::update_latency (bool playback)
4216 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback\n");
4218 boost::shared_ptr<RouteList> r = routes.reader ();
4221 /* reverse the list so that we work backwards from the last route to run to the first */
4222 reverse (r->begin(), r->end());
4225 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4226 DEBUG_TRACE (DEBUG::Latency, string_compose ("------------- Working on latency for %1\n", (*i)->name()));
4227 (*i)->set_latency_ranges (playback);
4228 DEBUG_TRACE (DEBUG::Latency, string_compose ("------------- Done working on latency for %1\n\n", (*i)->name()));