2 Copyright (C) 2006 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.
18 #include "pbd/error.h"
20 #include "ardour/amp.h"
21 #include "ardour/debug.h"
22 #include "ardour/delivery.h"
23 #include "ardour/diskstream.h"
24 #include "ardour/io_processor.h"
25 #include "ardour/meter.h"
26 #include "ardour/playlist.h"
27 #include "ardour/port.h"
28 #include "ardour/processor.h"
29 #include "ardour/route_group_specialized.h"
30 #include "ardour/session.h"
31 #include "ardour/session_playlists.h"
32 #include "ardour/track.h"
33 #include "ardour/utils.h"
38 using namespace ARDOUR;
41 Track::Track (Session& sess, string name, Route::Flag flag, TrackMode mode, DataType default_type)
42 : Route (sess, name, flag, default_type)
43 , _saved_meter_point (_meter_point)
45 , _monitoring (MonitorAuto)
47 _freeze_record.state = NoFreeze;
53 DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
63 boost::shared_ptr<Route> rp (shared_from_this());
64 boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
65 _rec_enable_control = boost::shared_ptr<RecEnableControl> (new RecEnableControl(rt));
66 _rec_enable_control->set_flags (Controllable::Toggle);
68 /* don't add rec_enable_control to controls because we don't want it to
69 * appear as an automatable parameter
71 track_number_changed.connect_same_thread (*this, boost::bind (&Track::resync_track_name, this));
72 _session.config.ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
78 Track::use_new_diskstream ()
80 boost::shared_ptr<Diskstream> ds = create_diskstream ();
82 ds->do_refill_with_alloc ();
83 ds->set_block_size (_session.get_block_size ());
84 ds->playlist()->set_orig_track_id (id());
96 Track::state (bool full)
98 XMLNode& root (Route::state (full));
99 root.add_property (X_("monitoring"), enum_2_string (_monitoring));
100 root.add_property (X_("saved-meter-point"), enum_2_string (_saved_meter_point));
101 root.add_child_nocopy (_rec_enable_control->get_state());
102 root.add_child_nocopy (_diskstream->get_state ());
108 Track::set_state (const XMLNode& node, int version)
110 if (Route::set_state (node, version)) {
116 if (version >= 3000) {
117 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
118 boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
119 ds->do_refill_with_alloc ();
125 _diskstream->playlist()->set_orig_track_id (id());
128 /* set rec-enable control *AFTER* setting up diskstream, because it may
129 want to operate on the diskstream as it sets its own state
132 XMLNodeList nlist = node.children();
133 for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
137 if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
138 if (prop->value() == X_("recenable")) {
139 _rec_enable_control->set_state (*child, version);
144 const XMLProperty* prop;
146 if ((prop = node.property (X_("monitoring"))) != 0) {
147 _monitoring = MonitorChoice (string_2_enum (prop->value(), _monitoring));
149 _monitoring = MonitorAuto;
152 if ((prop = node.property (X_("saved-meter-point"))) != 0) {
153 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
155 _saved_meter_point = _meter_point;
162 Track::get_template ()
164 return state (false);
167 Track::FreezeRecord::~FreezeRecord ()
169 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
175 Track::freeze_state() const
177 return _freeze_record.state;
180 Track::RecEnableControl::RecEnableControl (boost::shared_ptr<Track> t)
181 : AutomationControl (t->session(),
183 ParameterDescriptor(Evoral::Parameter(RecEnableAutomation)),
184 boost::shared_ptr<AutomationList>(),
188 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(RecEnableAutomation)));
193 Track::RecEnableControl::set_value (double val, Controllable::GroupControlDisposition /* group_override */)
196 set_value_unchecked (val);
201 Track::RecEnableControl::set_value_unchecked (double val)
203 boost::shared_ptr<Track> t = track.lock ();
208 t->set_record_enabled (val >= 0.5 ? true : false, this);
212 Track::RecEnableControl::get_value () const
214 boost::shared_ptr<Track> t = track.lock ();
219 return (t->record_enabled() ? 1.0 : 0.0);
223 Track::record_enabled () const
225 return _diskstream && _diskstream->record_enabled ();
231 bool will_record = true;
232 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
241 Track::prep_record_enabled (bool yn, void *src)
243 if (yn && record_safe ()) {
247 if (!_session.writable()) {
251 if (_freeze_record.state == Frozen) {
255 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
256 _route_group->apply (&Track::prep_record_enabled, yn, _route_group);
260 /* keep track of the meter point as it was before we rec-enabled */
261 if (!_diskstream->record_enabled()) {
262 _saved_meter_point = _meter_point;
268 will_follow = _diskstream->prep_record_enable ();
270 will_follow = _diskstream->prep_record_disable ();
275 if (_meter_point != MeterCustom) {
276 set_meter_point (MeterInput);
279 set_meter_point (_saved_meter_point);
285 Track::set_record_enabled (bool yn, void *src)
287 if (_diskstream->record_safe ()) {
291 if (!_session.writable()) {
295 if (_freeze_record.state == Frozen) {
299 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
300 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
304 _diskstream->set_record_enabled (yn);
306 _rec_enable_control->Changed ();
310 Track::record_safe () const
312 return _diskstream && _diskstream->record_safe ();
316 Track::set_record_safe (bool yn, void *src)
318 if (!_session.writable()) { /* REQUIRES REVIEW */
322 if (_freeze_record.state == Frozen) { /* REQUIRES REVIEW */
326 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
327 _route_group->apply (&Track::set_record_safe, yn, _route_group);
331 _diskstream->set_record_safe (yn);
335 Track::parameter_changed (string const & p)
337 if (p == "track-name-number") {
338 resync_track_name ();
340 else if (p == "track-name-take") {
341 resync_track_name ();
343 else if (p == "take-name") {
344 if (_session.config.get_track_name_take()) {
345 resync_track_name ();
351 Track::resync_track_name ()
357 Track::set_name (const string& str)
361 if (record_enabled() && _session.actively_recording()) {
362 /* this messes things up if done while recording */
366 string diskstream_name = "";
367 if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
368 // Note: any text is fine, legalize_for_path() fixes this later
369 diskstream_name += _session.config.get_take_name ();
370 diskstream_name += "_";
372 const int64_t tracknumber = track_number();
373 if (tracknumber > 0 && _session.config.get_track_name_number()) {
374 char num[64], fmt[10];
375 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
376 snprintf(num, sizeof(num), fmt, tracknumber);
377 diskstream_name += num;
378 diskstream_name += "_";
380 diskstream_name += str;
382 if (diskstream_name == _diskstream_name) {
385 _diskstream_name = diskstream_name;
387 _diskstream->set_write_source_name (diskstream_name);
389 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
390 if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
391 /* Only rename the diskstream (and therefore the playlist) if
392 a) the playlist has never had a region added to it and
393 b) there is only one playlist for this track.
395 If (a) is not followed, people can get confused if, say,
396 they have notes about a playlist with a given name and then
397 it changes (see mantis #4759).
399 If (b) is not followed, we rename the current playlist and not
400 the other ones, which is a bit confusing (see mantis #4977).
402 _diskstream->set_name (str);
405 /* save state so that the statefile fully reflects any filename changes */
407 if ((ret = Route::set_name (str)) == 0) {
408 _session.save_state ("");
415 Track::set_latency_compensation (framecnt_t longest_session_latency)
417 Route::set_latency_compensation (longest_session_latency);
418 _diskstream->set_roll_delay (_roll_delay);
422 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
424 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
430 bool can_record = _session.actively_recording ();
432 /* no outputs? nothing to do ... what happens if we have sends etc. ? */
434 if (n_outputs().n_total() == 0) {
438 /* not active ... do the minimum possible by just outputting silence */
442 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
448 if (session_state_changing) {
449 if (_session.transport_speed() != 0.0f) {
450 /* we're rolling but some state is changing (e.g. our diskstream contents)
451 so we cannot use them. Be silent till this is over. Don't declick.
453 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
455 passthru_silence (start_frame, end_frame, nframes, 0);
458 /* we're really not rolling, so we're either delivery silence or actually
459 monitoring, both of which are safe to do while session_state_changing is true.
463 _diskstream->check_record_status (start_frame, can_record);
467 MonitorState const s = monitoring_state ();
468 /* we are not rolling, so be silent even if we are monitoring disk, as there
469 will be no disk data coming in.
472 case MonitoringSilence:
478 case MonitoringInput:
486 //if we have an internal generator, let it play regardless of monitoring state
487 if (_have_internal_generator) {
491 _amp->apply_gain_automation (false);
493 /* if have_internal_generator, or .. */
497 if (_meter_point == MeterInput) {
498 /* still need input monitoring and metering */
500 bool const track_rec = _diskstream->record_enabled ();
501 bool const auto_input = _session.config.get_auto_input ();
502 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
503 bool const tape_machine_mode = Config->get_tape_machine_mode ();
504 bool no_meter = false;
506 /* this needs a proper K-map
507 * and should be separated into a function similar to monitoring_state()
508 * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
510 * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
512 if (!auto_input && !track_rec) {
515 else if (tape_machine_mode && !track_rec && auto_input) {
518 else if (!software_monitor && tape_machine_mode && !track_rec) {
521 else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
526 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
527 _meter->run (bufs, 0, 0, nframes, true);
528 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, nframes);
530 _input->process_input (_meter, start_frame, end_frame, nframes);
534 passthru_silence (start_frame, end_frame, nframes, 0);
538 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
540 fill_buffers_with_input (bufs, _input, nframes);
542 if (_meter_point == MeterInput) {
543 _meter->run (bufs, start_frame, end_frame, nframes, true);
546 passthru (bufs, start_frame, end_frame, nframes, false);
549 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
550 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
552 d->flush_buffers (nframes);
560 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
562 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
564 framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
565 if (can_internal_playback_seek(playback_distance)) {
566 internal_playback_seek(playback_distance);
571 if (n_outputs().n_total() == 0 && _processors.empty()) {
581 _amp->apply_gain_automation(false);
585 framecnt_t playback_distance;
587 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
589 int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
590 need_butler = _diskstream->commit (playback_distance);
595 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
599 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
600 diskstream_playlist_changed ();
601 ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
602 ds->RecordSafeChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_safe_changed, this));
603 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
604 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
608 Track::diskstream_playlist_changed ()
610 PlaylistChanged (); /* EMIT SIGNAL */
614 Track::diskstream_record_enable_changed ()
616 RecordEnableChanged (); /* EMIT SIGNAL */
620 Track::diskstream_record_safe_changed ()
622 RecordSafeChanged (); /* EMIT SIGNAL */
626 Track::diskstream_speed_changed ()
628 SpeedChanged (); /* EMIT SIGNAL */
632 Track::diskstream_alignment_style_changed ()
634 AlignmentStyleChanged (); /* EMIT SIGNAL */
637 boost::shared_ptr<Playlist>
640 return _diskstream->playlist ();
644 Track::request_input_monitoring (bool m)
646 _diskstream->request_input_monitoring (m);
650 Track::ensure_input_monitoring (bool m)
652 _diskstream->ensure_input_monitoring (m);
656 Track::destructive () const
658 return _diskstream->destructive ();
661 list<boost::shared_ptr<Source> > &
662 Track::last_capture_sources ()
664 return _diskstream->last_capture_sources ();
668 Track::set_capture_offset ()
670 _diskstream->set_capture_offset ();
674 Track::steal_write_source_name()
676 return _diskstream->steal_write_source_name ();
680 Track::reset_write_sources (bool r, bool force)
682 _diskstream->reset_write_sources (r, force);
686 Track::playback_buffer_load () const
688 return _diskstream->playback_buffer_load ();
692 Track::capture_buffer_load () const
694 return _diskstream->capture_buffer_load ();
700 return _diskstream->do_refill ();
704 Track::do_flush (RunContext c, bool force)
706 return _diskstream->do_flush (c, force);
710 Track::set_pending_overwrite (bool o)
712 _diskstream->set_pending_overwrite (o);
716 Track::seek (framepos_t p, bool complete_refill)
718 return _diskstream->seek (p, complete_refill);
722 Track::hidden () const
724 return _diskstream->hidden ();
728 Track::can_internal_playback_seek (framecnt_t p)
730 return _diskstream->can_internal_playback_seek (p);
734 Track::internal_playback_seek (framecnt_t p)
736 return _diskstream->internal_playback_seek (p);
740 Track::non_realtime_input_change ()
742 _diskstream->non_realtime_input_change ();
746 Track::non_realtime_locate (framepos_t p)
748 Route::non_realtime_locate (p);
751 /* don't waste i/o cycles and butler calls
752 for hidden (secret) tracks
754 _diskstream->non_realtime_locate (p);
759 Track::non_realtime_set_speed ()
761 _diskstream->non_realtime_set_speed ();
765 Track::overwrite_existing_buffers ()
767 return _diskstream->overwrite_existing_buffers ();
771 Track::get_captured_frames (uint32_t n) const
773 return _diskstream->get_captured_frames (n);
777 Track::set_loop (Location* l)
779 return _diskstream->set_loop (l);
783 Track::transport_looped (framepos_t p)
785 _diskstream->transport_looped (p);
789 Track::realtime_set_speed (double s, bool g)
791 return _diskstream->realtime_set_speed (s, g);
795 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
797 _diskstream->transport_stopped_wallclock (n, t, g);
801 Track::pending_overwrite () const
803 return _diskstream->pending_overwrite ();
807 Track::speed () const
809 return _diskstream->speed ();
813 Track::prepare_to_stop (framepos_t t, framepos_t a)
815 _diskstream->prepare_to_stop (t, a);
819 Track::set_slaved (bool s)
821 _diskstream->set_slaved (s);
827 return _diskstream->n_channels ();
831 Track::get_capture_start_frame (uint32_t n) const
833 return _diskstream->get_capture_start_frame (n);
837 Track::alignment_style () const
839 return _diskstream->alignment_style ();
843 Track::alignment_choice () const
845 return _diskstream->alignment_choice ();
849 Track::current_capture_start () const
851 return _diskstream->current_capture_start ();
855 Track::current_capture_end () const
857 return _diskstream->current_capture_end ();
861 Track::playlist_modified ()
863 _diskstream->playlist_modified ();
867 Track::use_playlist (boost::shared_ptr<Playlist> p)
869 int ret = _diskstream->use_playlist (p);
871 p->set_orig_track_id (id());
877 Track::use_copy_playlist ()
879 int ret = _diskstream->use_copy_playlist ();
882 _diskstream->playlist()->set_orig_track_id (id());
889 Track::use_new_playlist ()
891 int ret = _diskstream->use_new_playlist ();
894 _diskstream->playlist()->set_orig_track_id (id());
901 Track::set_align_style (AlignStyle s, bool force)
903 _diskstream->set_align_style (s, force);
907 Track::set_align_choice (AlignChoice s, bool force)
909 _diskstream->set_align_choice (s, force);
913 Track::using_diskstream_id (PBD::ID id) const
915 return (id == _diskstream->id ());
919 Track::set_block_size (pframes_t n)
921 Route::set_block_size (n);
922 _diskstream->set_block_size (n);
926 Track::adjust_playback_buffering ()
929 _diskstream->adjust_playback_buffering ();
934 Track::adjust_capture_buffering ()
937 _diskstream->adjust_capture_buffering ();
941 #ifdef USE_TRACKS_CODE_FEATURES
943 /* This is the Tracks version of Track::monitoring_state().
945 * Ardour developers: try to flag or fix issues if parts of the libardour API
946 * change in ways that invalidate this
950 Track::monitoring_state () const
952 /* Explicit requests */
954 if (_monitoring & MonitorInput) {
955 return MonitoringInput;
958 if (_monitoring & MonitorDisk) {
959 return MonitoringDisk;
962 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
963 I don't think it's ever going to be too pretty too look at.
966 // GZ: NOT USED IN TRACKS
967 //bool const auto_input = _session.config.get_auto_input ();
968 //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
969 //bool const tape_machine_mode = Config->get_tape_machine_mode ();
971 bool const roll = _session.transport_rolling ();
972 bool const track_rec = _diskstream->record_enabled ();
973 bool session_rec = _session.actively_recording ();
977 if (!session_rec && roll) {
978 return MonitoringDisk;
980 return MonitoringInput;
986 return MonitoringDisk;
990 return MonitoringSilence;
995 /* This is the Ardour/Mixbus version of Track::monitoring_state().
997 * Tracks developers: do NOT modify this method under any circumstances.
1001 Track::monitoring_state () const
1003 /* Explicit requests */
1005 if (_monitoring & MonitorInput) {
1006 return MonitoringInput;
1009 if (_monitoring & MonitorDisk) {
1010 return MonitoringDisk;
1013 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
1014 I don't think it's ever going to be too pretty too look at.
1017 bool const roll = _session.transport_rolling ();
1018 bool const track_rec = _diskstream->record_enabled ();
1019 bool const auto_input = _session.config.get_auto_input ();
1020 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
1021 bool const tape_machine_mode = Config->get_tape_machine_mode ();
1024 /* I suspect that just use actively_recording() is good enough all the
1025 * time, but just to keep the semantics the same as they were before
1026 * sept 26th 2012, we differentiate between the cases where punch is
1027 * enabled and those where it is not.
1030 if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
1031 session_rec = _session.actively_recording ();
1033 session_rec = _session.get_record_enabled();
1038 if (!session_rec && roll && auto_input) {
1039 return MonitoringDisk;
1041 return software_monitor ? MonitoringInput : MonitoringSilence;
1046 if (tape_machine_mode) {
1048 return MonitoringDisk;
1052 if (!roll && auto_input) {
1053 return software_monitor ? MonitoringInput : MonitoringSilence;
1055 return MonitoringDisk;
1061 abort(); /* NOTREACHED */
1062 return MonitoringSilence;
1068 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
1070 /* never declick if there is an internal generator - we just want it to
1071 keep generating sound without interruption.
1073 ditto if we are monitoring inputs.
1076 if (_have_internal_generator || monitoring_choice() == MonitorInput) {
1081 declick = _pending_declick;
1085 Amp::declick (bufs, nframes, declick);
1090 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
1092 if (_roll_delay > nframes) {
1094 _roll_delay -= nframes;
1095 silence_unlocked (nframes);
1096 /* transport frame is not legal for caller to use */
1099 } else if (_roll_delay > 0) {
1101 nframes -= _roll_delay;
1102 silence_unlocked (_roll_delay);
1103 transport_frame += _roll_delay;
1105 /* shuffle all the port buffers for things that lead "out" of this Route
1106 to reflect that we just wrote _roll_delay frames of silence.
1109 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1110 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1111 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1113 iop->increment_port_buffer_offset (_roll_delay);
1116 _output->increment_port_buffer_offset (_roll_delay);
1126 Track::set_monitoring (MonitorChoice mc)
1128 if (mc != _monitoring) {
1131 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1132 (*i)->monitoring_changed ();
1135 MonitoringChanged (); /* EMIT SIGNAL */
1140 Track::metering_state () const
1143 if (_session.transport_rolling ()) {
1144 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1145 rv = _meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled());
1147 // track no_roll() always metering if
1148 rv = _meter_point == MeterInput;
1150 return rv ? MeteringInput : MeteringRoute;