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)
195 boost::shared_ptr<Track> t = track.lock ();
200 t->set_record_enabled (val >= 0.5 ? true : false, this);
204 Track::RecEnableControl::get_value () const
206 boost::shared_ptr<Track> t = track.lock ();
211 return (t->record_enabled() ? 1.0 : 0.0);
215 Track::record_enabled () const
217 return _diskstream && _diskstream->record_enabled ();
223 bool will_record = true;
224 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
233 Track::prep_record_enabled (bool yn, void *src)
235 if (yn && record_safe ()) {
239 if (!_session.writable()) {
243 if (_freeze_record.state == Frozen) {
247 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
248 _route_group->apply (&Track::prep_record_enabled, yn, _route_group);
252 /* keep track of the meter point as it was before we rec-enabled */
253 if (!_diskstream->record_enabled()) {
254 _saved_meter_point = _meter_point;
260 will_follow = _diskstream->prep_record_enable ();
262 will_follow = _diskstream->prep_record_disable ();
267 if (_meter_point != MeterCustom) {
268 set_meter_point (MeterInput);
271 set_meter_point (_saved_meter_point);
277 Track::set_record_enabled (bool yn, void *src)
279 if (_diskstream->record_safe ()) {
283 if (!_session.writable()) {
287 if (_freeze_record.state == Frozen) {
291 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
292 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
296 _diskstream->set_record_enabled (yn);
298 _rec_enable_control->Changed ();
302 Track::record_safe () const
304 return _diskstream && _diskstream->record_safe ();
308 Track::set_record_safe (bool yn, void *src)
310 if (!_session.writable()) { /* REQUIRES REVIEW */
314 if (_freeze_record.state == Frozen) { /* REQUIRES REVIEW */
318 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
319 _route_group->apply (&Track::set_record_safe, yn, _route_group);
323 _diskstream->set_record_safe (yn);
327 Track::parameter_changed (string const & p)
329 if (p == "track-name-number") {
330 resync_track_name ();
332 else if (p == "track-name-take") {
333 resync_track_name ();
335 else if (p == "take-name") {
336 if (_session.config.get_track_name_take()) {
337 resync_track_name ();
343 Track::resync_track_name ()
349 Track::set_name (const string& str)
353 if (record_enabled() && _session.actively_recording()) {
354 /* this messes things up if done while recording */
358 string diskstream_name = "";
359 if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
360 // Note: any text is fine, legalize_for_path() fixes this later
361 diskstream_name += _session.config.get_take_name ();
362 diskstream_name += "_";
364 const int64_t tracknumber = track_number();
365 if (tracknumber > 0 && _session.config.get_track_name_number()) {
366 char num[64], fmt[10];
367 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
368 snprintf(num, sizeof(num), fmt, tracknumber);
369 diskstream_name += num;
370 diskstream_name += "_";
372 diskstream_name += str;
374 if (diskstream_name == _diskstream_name) {
377 _diskstream_name = diskstream_name;
379 _diskstream->set_write_source_name (diskstream_name);
381 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
382 if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
383 /* Only rename the diskstream (and therefore the playlist) if
384 a) the playlist has never had a region added to it and
385 b) there is only one playlist for this track.
387 If (a) is not followed, people can get confused if, say,
388 they have notes about a playlist with a given name and then
389 it changes (see mantis #4759).
391 If (b) is not followed, we rename the current playlist and not
392 the other ones, which is a bit confusing (see mantis #4977).
394 _diskstream->set_name (str);
397 /* save state so that the statefile fully reflects any filename changes */
399 if ((ret = Route::set_name (str)) == 0) {
400 _session.save_state ("");
407 Track::set_latency_compensation (framecnt_t longest_session_latency)
409 Route::set_latency_compensation (longest_session_latency);
410 _diskstream->set_roll_delay (_roll_delay);
414 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
416 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
422 bool can_record = _session.actively_recording ();
424 /* no outputs? nothing to do ... what happens if we have sends etc. ? */
426 if (n_outputs().n_total() == 0) {
430 /* not active ... do the minimum possible by just outputting silence */
434 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
440 if (session_state_changing) {
441 if (_session.transport_speed() != 0.0f) {
442 /* we're rolling but some state is changing (e.g. our diskstream contents)
443 so we cannot use them. Be silent till this is over. Don't declick.
445 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
447 passthru_silence (start_frame, end_frame, nframes, 0);
450 /* we're really not rolling, so we're either delivery silence or actually
451 monitoring, both of which are safe to do while session_state_changing is true.
455 _diskstream->check_record_status (start_frame, can_record);
459 MonitorState const s = monitoring_state ();
460 /* we are not rolling, so be silent even if we are monitoring disk, as there
461 will be no disk data coming in.
464 case MonitoringSilence:
470 case MonitoringInput:
478 //if we have an internal generator, let it play regardless of monitoring state
479 if (_have_internal_generator) {
483 _amp->apply_gain_automation (false);
485 /* if have_internal_generator, or .. */
489 if (_meter_point == MeterInput) {
490 /* still need input monitoring and metering */
492 bool const track_rec = _diskstream->record_enabled ();
493 bool const auto_input = _session.config.get_auto_input ();
494 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
495 bool const tape_machine_mode = Config->get_tape_machine_mode ();
496 bool no_meter = false;
498 /* this needs a proper K-map
499 * and should be separated into a function similar to monitoring_state()
500 * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
502 * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
504 if (!auto_input && !track_rec) {
507 else if (tape_machine_mode && !track_rec && auto_input) {
510 else if (!software_monitor && tape_machine_mode && !track_rec) {
513 else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
518 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
519 _meter->run (bufs, 0, 0, nframes, true);
520 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, nframes);
522 _input->process_input (_meter, start_frame, end_frame, nframes);
526 passthru_silence (start_frame, end_frame, nframes, 0);
530 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
532 fill_buffers_with_input (bufs, _input, nframes);
534 if (_meter_point == MeterInput) {
535 _meter->run (bufs, start_frame, end_frame, nframes, true);
538 passthru (bufs, start_frame, end_frame, nframes, false);
541 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
542 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
544 d->flush_buffers (nframes);
552 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
554 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
556 framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
557 if (can_internal_playback_seek(playback_distance)) {
558 internal_playback_seek(playback_distance);
563 if (n_outputs().n_total() == 0 && _processors.empty()) {
573 _amp->apply_gain_automation(false);
577 framecnt_t playback_distance;
579 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
581 int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
582 need_butler = _diskstream->commit (playback_distance);
587 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
591 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
592 diskstream_playlist_changed ();
593 ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
594 ds->RecordSafeChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_safe_changed, this));
595 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
596 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
600 Track::diskstream_playlist_changed ()
602 PlaylistChanged (); /* EMIT SIGNAL */
606 Track::diskstream_record_enable_changed ()
608 RecordEnableChanged (); /* EMIT SIGNAL */
612 Track::diskstream_record_safe_changed ()
614 RecordSafeChanged (); /* EMIT SIGNAL */
618 Track::diskstream_speed_changed ()
620 SpeedChanged (); /* EMIT SIGNAL */
624 Track::diskstream_alignment_style_changed ()
626 AlignmentStyleChanged (); /* EMIT SIGNAL */
629 boost::shared_ptr<Playlist>
632 return _diskstream->playlist ();
636 Track::request_input_monitoring (bool m)
638 _diskstream->request_input_monitoring (m);
642 Track::ensure_input_monitoring (bool m)
644 _diskstream->ensure_input_monitoring (m);
648 Track::destructive () const
650 return _diskstream->destructive ();
653 list<boost::shared_ptr<Source> > &
654 Track::last_capture_sources ()
656 return _diskstream->last_capture_sources ();
660 Track::set_capture_offset ()
662 _diskstream->set_capture_offset ();
666 Track::steal_write_source_name()
668 return _diskstream->steal_write_source_name ();
672 Track::reset_write_sources (bool r, bool force)
674 _diskstream->reset_write_sources (r, force);
678 Track::playback_buffer_load () const
680 return _diskstream->playback_buffer_load ();
684 Track::capture_buffer_load () const
686 return _diskstream->capture_buffer_load ();
692 return _diskstream->do_refill ();
696 Track::do_flush (RunContext c, bool force)
698 return _diskstream->do_flush (c, force);
702 Track::set_pending_overwrite (bool o)
704 _diskstream->set_pending_overwrite (o);
708 Track::seek (framepos_t p, bool complete_refill)
710 return _diskstream->seek (p, complete_refill);
714 Track::hidden () const
716 return _diskstream->hidden ();
720 Track::can_internal_playback_seek (framecnt_t p)
722 return _diskstream->can_internal_playback_seek (p);
726 Track::internal_playback_seek (framecnt_t p)
728 return _diskstream->internal_playback_seek (p);
732 Track::non_realtime_input_change ()
734 _diskstream->non_realtime_input_change ();
738 Track::non_realtime_locate (framepos_t p)
740 Route::non_realtime_locate (p);
743 /* don't waste i/o cycles and butler calls
744 for hidden (secret) tracks
746 _diskstream->non_realtime_locate (p);
751 Track::non_realtime_set_speed ()
753 _diskstream->non_realtime_set_speed ();
757 Track::overwrite_existing_buffers ()
759 return _diskstream->overwrite_existing_buffers ();
763 Track::get_captured_frames (uint32_t n) const
765 return _diskstream->get_captured_frames (n);
769 Track::set_loop (Location* l)
771 return _diskstream->set_loop (l);
775 Track::transport_looped (framepos_t p)
777 _diskstream->transport_looped (p);
781 Track::realtime_set_speed (double s, bool g)
783 return _diskstream->realtime_set_speed (s, g);
787 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
789 _diskstream->transport_stopped_wallclock (n, t, g);
793 Track::pending_overwrite () const
795 return _diskstream->pending_overwrite ();
799 Track::speed () const
801 return _diskstream->speed ();
805 Track::prepare_to_stop (framepos_t t, framepos_t a)
807 _diskstream->prepare_to_stop (t, a);
811 Track::set_slaved (bool s)
813 _diskstream->set_slaved (s);
819 return _diskstream->n_channels ();
823 Track::get_capture_start_frame (uint32_t n) const
825 return _diskstream->get_capture_start_frame (n);
829 Track::alignment_style () const
831 return _diskstream->alignment_style ();
835 Track::alignment_choice () const
837 return _diskstream->alignment_choice ();
841 Track::current_capture_start () const
843 return _diskstream->current_capture_start ();
847 Track::current_capture_end () const
849 return _diskstream->current_capture_end ();
853 Track::playlist_modified ()
855 _diskstream->playlist_modified ();
859 Track::use_playlist (boost::shared_ptr<Playlist> p)
861 int ret = _diskstream->use_playlist (p);
863 p->set_orig_track_id (id());
869 Track::use_copy_playlist ()
871 int ret = _diskstream->use_copy_playlist ();
874 _diskstream->playlist()->set_orig_track_id (id());
881 Track::use_new_playlist ()
883 int ret = _diskstream->use_new_playlist ();
886 _diskstream->playlist()->set_orig_track_id (id());
893 Track::set_align_style (AlignStyle s, bool force)
895 _diskstream->set_align_style (s, force);
899 Track::set_align_choice (AlignChoice s, bool force)
901 _diskstream->set_align_choice (s, force);
905 Track::using_diskstream_id (PBD::ID id) const
907 return (id == _diskstream->id ());
911 Track::set_block_size (pframes_t n)
913 Route::set_block_size (n);
914 _diskstream->set_block_size (n);
918 Track::adjust_playback_buffering ()
921 _diskstream->adjust_playback_buffering ();
926 Track::adjust_capture_buffering ()
929 _diskstream->adjust_capture_buffering ();
933 #ifdef USE_TRACKS_CODE_FEATURES
935 /* This is the Tracks version of Track::monitoring_state().
937 * Ardour developers: try to flag or fix issues if parts of the libardour API
938 * change in ways that invalidate this
942 Track::monitoring_state () const
944 /* Explicit requests */
946 if (_monitoring & MonitorInput) {
947 return MonitoringInput;
950 if (_monitoring & MonitorDisk) {
951 return MonitoringDisk;
954 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
955 I don't think it's ever going to be too pretty too look at.
958 // GZ: NOT USED IN TRACKS
959 //bool const auto_input = _session.config.get_auto_input ();
960 //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
961 //bool const tape_machine_mode = Config->get_tape_machine_mode ();
963 bool const roll = _session.transport_rolling ();
964 bool const track_rec = _diskstream->record_enabled ();
965 bool session_rec = _session.actively_recording ();
969 if (!session_rec && roll) {
970 return MonitoringDisk;
972 return MonitoringInput;
978 return MonitoringDisk;
982 return MonitoringSilence;
987 /* This is the Ardour/Mixbus version of Track::monitoring_state().
989 * Tracks developers: do NOT modify this method under any circumstances.
993 Track::monitoring_state () const
995 /* Explicit requests */
997 if (_monitoring & MonitorInput) {
998 return MonitoringInput;
1001 if (_monitoring & MonitorDisk) {
1002 return MonitoringDisk;
1005 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
1006 I don't think it's ever going to be too pretty too look at.
1009 bool const roll = _session.transport_rolling ();
1010 bool const track_rec = _diskstream->record_enabled ();
1011 bool const auto_input = _session.config.get_auto_input ();
1012 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
1013 bool const tape_machine_mode = Config->get_tape_machine_mode ();
1016 /* I suspect that just use actively_recording() is good enough all the
1017 * time, but just to keep the semantics the same as they were before
1018 * sept 26th 2012, we differentiate between the cases where punch is
1019 * enabled and those where it is not.
1022 if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
1023 session_rec = _session.actively_recording ();
1025 session_rec = _session.get_record_enabled();
1030 if (!session_rec && roll && auto_input) {
1031 return MonitoringDisk;
1033 return software_monitor ? MonitoringInput : MonitoringSilence;
1038 if (tape_machine_mode) {
1040 return MonitoringDisk;
1044 if (!roll && auto_input) {
1045 return software_monitor ? MonitoringInput : MonitoringSilence;
1047 return MonitoringDisk;
1053 abort(); /* NOTREACHED */
1054 return MonitoringSilence;
1060 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
1062 /* never declick if there is an internal generator - we just want it to
1063 keep generating sound without interruption.
1065 ditto if we are monitoring inputs.
1068 if (_have_internal_generator || monitoring_choice() == MonitorInput) {
1073 declick = _pending_declick;
1077 Amp::declick (bufs, nframes, declick);
1082 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
1084 if (_roll_delay > nframes) {
1086 _roll_delay -= nframes;
1087 silence_unlocked (nframes);
1088 /* transport frame is not legal for caller to use */
1091 } else if (_roll_delay > 0) {
1093 nframes -= _roll_delay;
1094 silence_unlocked (_roll_delay);
1095 transport_frame += _roll_delay;
1097 /* shuffle all the port buffers for things that lead "out" of this Route
1098 to reflect that we just wrote _roll_delay frames of silence.
1101 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1102 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1103 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1105 iop->increment_port_buffer_offset (_roll_delay);
1108 _output->increment_port_buffer_offset (_roll_delay);
1118 Track::set_monitoring (MonitorChoice mc)
1120 if (mc != _monitoring) {
1123 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1124 (*i)->monitoring_changed ();
1127 MonitoringChanged (); /* EMIT SIGNAL */
1132 Track::metering_state () const
1135 if (_session.transport_rolling ()) {
1136 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1137 rv = _meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled());
1139 // track no_roll() always metering if
1140 rv = _meter_point == MeterInput;
1142 return rv ? MeteringInput : MeteringRoute;