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/monitor_control.h"
27 #include "ardour/playlist.h"
28 #include "ardour/port.h"
29 #include "ardour/processor.h"
30 #include "ardour/profile.h"
31 #include "ardour/record_enable_control.h"
32 #include "ardour/record_safe_control.h"
33 #include "ardour/route_group_specialized.h"
34 #include "ardour/session.h"
35 #include "ardour/session_playlists.h"
36 #include "ardour/track.h"
37 #include "ardour/utils.h"
42 using namespace ARDOUR;
45 Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode mode, DataType default_type)
46 : Route (sess, name, flag, default_type)
47 , _saved_meter_point (_meter_point)
50 _freeze_record.state = NoFreeze;
56 DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
66 boost::shared_ptr<Route> rp (shared_from_this());
67 boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
69 _record_enable_control.reset (new RecordEnableControl (_session, X_("recenable"), *this));
70 add_control (_record_enable_control);
72 _record_safe_control.reset (new RecordSafeControl (_session, X_("recsafe"), *this));
73 add_control (_record_safe_control);
75 _monitoring_control.reset (new MonitorControl (_session, X_("monitoring"), *this));
76 add_control (_monitoring_control);
78 _session.config.ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
80 _monitoring_control->Changed.connect_same_thread (*this, boost::bind (&Track::monitoring_changed, this, _1, _2));
81 _record_safe_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_safe_changed, this, _1, _2));
82 _record_enable_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_enable_changed, this, _1, _2));
88 Track::use_new_diskstream ()
90 boost::shared_ptr<Diskstream> ds = create_diskstream ();
92 ds->do_refill_with_alloc ();
93 ds->set_block_size (_session.get_block_size ());
94 ds->playlist()->set_orig_track_id (id());
106 Track::state (bool full)
108 XMLNode& root (Route::state (full));
110 root.add_child_nocopy (_monitoring_control->get_state ());
111 root.add_child_nocopy (_record_safe_control->get_state ());
112 root.add_child_nocopy (_record_enable_control->get_state ());
114 root.add_property (X_("saved-meter-point"), enum_2_string (_saved_meter_point));
115 root.add_child_nocopy (_diskstream->get_state ());
121 Track::set_state (const XMLNode& node, int version)
123 if (Route::set_state (node, version)) {
129 if (version >= 3000) {
130 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
131 boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
132 ds->do_refill_with_alloc ();
138 _diskstream->playlist()->set_orig_track_id (id());
141 /* set rec-enable control *AFTER* setting up diskstream, because it may
142 want to operate on the diskstream as it sets its own state
145 XMLNodeList nlist = node.children();
146 for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
149 XMLProperty const * prop;
151 if (child->name() == Controllable::xml_node_name) {
152 if ((prop = child->property ("name")) == 0) {
156 if (prop->value() == _record_enable_control->name()) {
157 _record_enable_control->set_state (*child, version);
158 } else if (prop->value() == _record_safe_control->name()) {
159 _record_safe_control->set_state (*child, version);
160 } else if (prop->value() == _monitoring_control->name()) {
161 _monitoring_control->set_state (*child, version);
166 XMLProperty const * prop;
168 if ((prop = node.property (X_("saved-meter-point"))) != 0) {
169 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
171 _saved_meter_point = _meter_point;
178 Track::get_template ()
180 return state (false);
183 Track::FreezeRecord::~FreezeRecord ()
185 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
191 Track::freeze_state() const
193 return _freeze_record.state;
199 bool will_record = true;
200 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
209 Track::prep_record_enabled (bool yn)
211 if (yn && _record_safe_control->get_value()) {
215 if (!can_be_record_enabled()) {
219 /* keep track of the meter point as it was before we rec-enabled */
220 if (!_diskstream->record_enabled()) {
221 _saved_meter_point = _meter_point;
227 will_follow = _diskstream->prep_record_enable ();
229 will_follow = _diskstream->prep_record_disable ();
234 if (_meter_point != MeterCustom) {
235 set_meter_point (MeterInput);
238 set_meter_point (_saved_meter_point);
246 Track::record_enable_changed (bool, Controllable::GroupControlDisposition)
248 _diskstream->set_record_enabled (_record_enable_control->get_value());
252 Track::record_safe_changed (bool, Controllable::GroupControlDisposition)
254 _diskstream->set_record_safe (_record_safe_control->get_value());
258 Track::can_be_record_safe ()
260 return !_record_enable_control->get_value() && _diskstream && _session.writable() && (_freeze_record.state != Frozen);
264 Track::can_be_record_enabled ()
266 return !_record_safe_control->get_value() && _diskstream && !_diskstream->record_safe() && _session.writable() && (_freeze_record.state != Frozen);
270 Track::parameter_changed (string const & p)
272 if (p == "track-name-number") {
273 resync_track_name ();
275 else if (p == "track-name-take") {
276 resync_track_name ();
278 else if (p == "take-name") {
279 if (_session.config.get_track_name_take()) {
280 resync_track_name ();
286 Track::resync_track_name ()
292 Track::set_name (const string& str)
296 if (_record_enable_control->get_value() && _session.actively_recording()) {
297 /* this messes things up if done while recording */
301 string diskstream_name = "";
302 if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
303 // Note: any text is fine, legalize_for_path() fixes this later
304 diskstream_name += _session.config.get_take_name ();
305 diskstream_name += "_";
307 const int64_t tracknumber = track_number();
308 if (tracknumber > 0 && _session.config.get_track_name_number()) {
309 char num[64], fmt[10];
310 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
311 snprintf(num, sizeof(num), fmt, tracknumber);
312 diskstream_name += num;
313 diskstream_name += "_";
315 diskstream_name += str;
317 if (diskstream_name == _diskstream_name) {
320 _diskstream_name = diskstream_name;
322 _diskstream->set_write_source_name (diskstream_name);
324 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
325 if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
326 /* Only rename the diskstream (and therefore the playlist) if
327 a) the playlist has never had a region added to it and
328 b) there is only one playlist for this track.
330 If (a) is not followed, people can get confused if, say,
331 they have notes about a playlist with a given name and then
332 it changes (see mantis #4759).
334 If (b) is not followed, we rename the current playlist and not
335 the other ones, which is a bit confusing (see mantis #4977).
337 _diskstream->set_name (str);
340 /* save state so that the statefile fully reflects any filename changes */
342 if ((ret = Route::set_name (str)) == 0) {
343 _session.save_state ("");
350 Track::set_latency_compensation (framecnt_t longest_session_latency)
352 Route::set_latency_compensation (longest_session_latency);
353 _diskstream->set_roll_delay (_roll_delay);
357 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
359 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
365 bool can_record = _session.actively_recording ();
367 /* no outputs? nothing to do ... what happens if we have sends etc. ? */
369 if (n_outputs().n_total() == 0 && !ARDOUR::Profile->get_mixbus()) {
370 //Note: Mixbus has its own output mechanism, so we should operate even if no explicit outputs are assigned
374 /* not active ... do the minimum possible by just outputting silence */
378 if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled())) {
384 if (session_state_changing) {
385 if (_session.transport_speed() != 0.0f) {
386 /* we're rolling but some state is changing (e.g. our diskstream contents)
387 so we cannot use them. Be silent till this is over. Don't declick.
389 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
391 passthru_silence (start_frame, end_frame, nframes, 0);
394 /* we're really not rolling, so we're either delivery silence or actually
395 monitoring, both of which are safe to do while session_state_changing is true.
399 _diskstream->check_record_status (start_frame, can_record);
403 MonitorState const s = monitoring_state ();
404 /* we are not rolling, so be silent even if we are monitoring disk, as there
405 will be no disk data coming in.
408 case MonitoringSilence:
414 case MonitoringInput:
422 //if we have an internal generator, let it play regardless of monitoring state
423 if (_have_internal_generator) {
427 _amp->apply_gain_automation (false);
429 /* if have_internal_generator, or .. */
433 if (_meter_point == MeterInput) {
434 /* still need input monitoring and metering */
436 bool const track_rec = _diskstream->record_enabled ();
437 bool const auto_input = _session.config.get_auto_input ();
438 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
439 bool const tape_machine_mode = Config->get_tape_machine_mode ();
440 bool no_meter = false;
442 /* this needs a proper K-map
443 * and should be separated into a function similar to monitoring_state()
444 * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
446 * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
448 if (!auto_input && !track_rec) {
451 else if (tape_machine_mode && !track_rec && auto_input) {
454 else if (!software_monitor && tape_machine_mode && !track_rec) {
457 else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
462 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
463 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
464 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, speed(), nframes);
466 _input->process_input (_meter, start_frame, end_frame, speed(), nframes);
470 passthru_silence (start_frame, end_frame, nframes, 0);
474 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
476 fill_buffers_with_input (bufs, _input, nframes);
478 if (_meter_point == MeterInput) {
479 _meter->run (bufs, start_frame, end_frame, 1.0 /*speed()*/, nframes, true);
482 passthru (bufs, start_frame, end_frame, nframes, false);
485 flush_processor_buffers_locked (nframes);
491 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
493 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
495 framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
496 if (can_internal_playback_seek(playback_distance)) {
497 internal_playback_seek(playback_distance);
502 if (n_outputs().n_total() == 0 && _processors.empty()) {
512 _amp->apply_gain_automation(false);
515 flush_processor_buffers_locked (nframes);
517 framecnt_t playback_distance;
519 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
521 int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
522 need_butler = _diskstream->commit (playback_distance);
527 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
531 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
532 diskstream_playlist_changed ();
533 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
534 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
538 Track::diskstream_playlist_changed ()
540 PlaylistChanged (); /* EMIT SIGNAL */
544 Track::diskstream_speed_changed ()
546 SpeedChanged (); /* EMIT SIGNAL */
550 Track::diskstream_alignment_style_changed ()
552 AlignmentStyleChanged (); /* EMIT SIGNAL */
555 boost::shared_ptr<Playlist>
558 return _diskstream->playlist ();
562 Track::request_input_monitoring (bool m)
564 _diskstream->request_input_monitoring (m);
568 Track::ensure_input_monitoring (bool m)
570 _diskstream->ensure_input_monitoring (m);
574 Track::destructive () const
576 return _diskstream->destructive ();
579 list<boost::shared_ptr<Source> > &
580 Track::last_capture_sources ()
582 return _diskstream->last_capture_sources ();
586 Track::set_capture_offset ()
588 _diskstream->set_capture_offset ();
592 Track::steal_write_source_name()
594 return _diskstream->steal_write_source_name ();
598 Track::reset_write_sources (bool r, bool force)
600 _diskstream->reset_write_sources (r, force);
604 Track::playback_buffer_load () const
606 return _diskstream->playback_buffer_load ();
610 Track::capture_buffer_load () const
612 return _diskstream->capture_buffer_load ();
618 return _diskstream->do_refill ();
622 Track::do_flush (RunContext c, bool force)
624 return _diskstream->do_flush (c, force);
628 Track::set_pending_overwrite (bool o)
630 _diskstream->set_pending_overwrite (o);
634 Track::seek (framepos_t p, bool complete_refill)
636 return _diskstream->seek (p, complete_refill);
640 Track::hidden () const
642 return _diskstream->hidden ();
646 Track::can_internal_playback_seek (framecnt_t p)
648 return _diskstream->can_internal_playback_seek (p);
652 Track::internal_playback_seek (framecnt_t p)
654 return _diskstream->internal_playback_seek (p);
658 Track::non_realtime_input_change ()
660 _diskstream->non_realtime_input_change ();
664 Track::non_realtime_locate (framepos_t p)
666 Route::non_realtime_locate (p);
669 /* don't waste i/o cycles and butler calls
670 for hidden (secret) tracks
672 _diskstream->non_realtime_locate (p);
677 Track::non_realtime_set_speed ()
679 _diskstream->non_realtime_set_speed ();
683 Track::overwrite_existing_buffers ()
685 return _diskstream->overwrite_existing_buffers ();
689 Track::get_captured_frames (uint32_t n) const
691 return _diskstream->get_captured_frames (n);
695 Track::set_loop (Location* l)
697 return _diskstream->set_loop (l);
701 Track::transport_looped (framepos_t p)
703 _diskstream->transport_looped (p);
707 Track::realtime_set_speed (double s, bool g)
709 return _diskstream->realtime_set_speed (s, g);
713 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
715 _diskstream->transport_stopped_wallclock (n, t, g);
719 Track::pending_overwrite () const
721 return _diskstream->pending_overwrite ();
725 Track::speed () const
727 return _diskstream->speed ();
731 Track::prepare_to_stop (framepos_t t, framepos_t a)
733 _diskstream->prepare_to_stop (t, a);
737 Track::set_slaved (bool s)
739 _diskstream->set_slaved (s);
745 return _diskstream->n_channels ();
749 Track::get_capture_start_frame (uint32_t n) const
751 return _diskstream->get_capture_start_frame (n);
755 Track::alignment_style () const
757 return _diskstream->alignment_style ();
761 Track::alignment_choice () const
763 return _diskstream->alignment_choice ();
767 Track::current_capture_start () const
769 return _diskstream->current_capture_start ();
773 Track::current_capture_end () const
775 return _diskstream->current_capture_end ();
779 Track::playlist_modified ()
781 _diskstream->playlist_modified ();
785 Track::use_playlist (boost::shared_ptr<Playlist> p)
787 int ret = _diskstream->use_playlist (p);
789 p->set_orig_track_id (id());
795 Track::use_copy_playlist ()
797 int ret = _diskstream->use_copy_playlist ();
800 _diskstream->playlist()->set_orig_track_id (id());
807 Track::use_new_playlist ()
809 int ret = _diskstream->use_new_playlist ();
812 _diskstream->playlist()->set_orig_track_id (id());
819 Track::set_align_style (AlignStyle s, bool force)
821 _diskstream->set_align_style (s, force);
825 Track::set_align_choice (AlignChoice s, bool force)
827 _diskstream->set_align_choice (s, force);
831 Track::using_diskstream_id (PBD::ID id) const
833 return (id == _diskstream->id ());
837 Track::set_block_size (pframes_t n)
839 Route::set_block_size (n);
840 _diskstream->set_block_size (n);
844 Track::adjust_playback_buffering ()
847 _diskstream->adjust_playback_buffering ();
852 Track::adjust_capture_buffering ()
855 _diskstream->adjust_capture_buffering ();
859 #ifdef USE_TRACKS_CODE_FEATURES
861 /* This is the Tracks version of Track::monitoring_state().
863 * Ardour developers: try to flag or fix issues if parts of the libardour API
864 * change in ways that invalidate this
868 Track::monitoring_state () const
870 /* Explicit requests */
872 if (_monitoring & MonitorInput) {
873 return MonitoringInput;
876 if (_monitoring & MonitorDisk) {
877 return MonitoringDisk;
880 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
881 I don't think it's ever going to be too pretty too look at.
884 // GZ: NOT USED IN TRACKS
885 //bool const auto_input = _session.config.get_auto_input ();
886 //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
887 //bool const tape_machine_mode = Config->get_tape_machine_mode ();
889 bool const roll = _session.transport_rolling ();
890 bool const track_rec = _diskstream->record_enabled ();
891 bool session_rec = _session.actively_recording ();
895 if (!session_rec && roll) {
896 return MonitoringDisk;
898 return MonitoringInput;
904 return MonitoringDisk;
908 return MonitoringSilence;
913 /* This is the Ardour/Mixbus version of Track::monitoring_state().
915 * Tracks developers: do NOT modify this method under any circumstances.
919 Track::monitoring_state () const
921 /* Explicit requests */
922 MonitorChoice m (_monitoring_control->monitoring_choice());
924 if (m & MonitorInput) {
925 return MonitoringInput;
928 if (m & MonitorDisk) {
929 return MonitoringDisk;
932 switch (_session.config.get_session_monitoring ()) {
934 return MonitoringDisk;
937 return MonitoringInput;
943 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
944 I don't think it's ever going to be too pretty too look at.
947 bool const roll = _session.transport_rolling ();
948 bool const track_rec = _diskstream->record_enabled ();
949 bool const auto_input = _session.config.get_auto_input ();
950 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
951 bool const tape_machine_mode = Config->get_tape_machine_mode ();
954 /* I suspect that just use actively_recording() is good enough all the
955 * time, but just to keep the semantics the same as they were before
956 * sept 26th 2012, we differentiate between the cases where punch is
957 * enabled and those where it is not.
960 if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) {
961 session_rec = _session.actively_recording ();
963 session_rec = _session.get_record_enabled();
968 if (!session_rec && roll && auto_input) {
969 return MonitoringDisk;
971 return software_monitor ? MonitoringInput : MonitoringSilence;
976 if (tape_machine_mode) {
978 return MonitoringDisk;
982 if (!roll && auto_input) {
983 return software_monitor ? MonitoringInput : MonitoringSilence;
985 return MonitoringDisk;
991 abort(); /* NOTREACHED */
992 return MonitoringSilence;
998 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
1000 /* never declick if there is an internal generator - we just want it to
1001 keep generating sound without interruption.
1003 ditto if we are monitoring inputs.
1006 if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) {
1011 declick = _pending_declick;
1015 Amp::declick (bufs, nframes, declick);
1020 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
1022 if (_roll_delay > nframes) {
1024 _roll_delay -= nframes;
1025 silence_unlocked (nframes);
1026 /* transport frame is not legal for caller to use */
1029 } else if (_roll_delay > 0) {
1031 nframes -= _roll_delay;
1032 silence_unlocked (_roll_delay);
1033 transport_frame += _roll_delay;
1035 /* shuffle all the port buffers for things that lead "out" of this Route
1036 to reflect that we just wrote _roll_delay frames of silence.
1039 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1040 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1041 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1043 iop->increment_port_buffer_offset (_roll_delay);
1046 _output->increment_port_buffer_offset (_roll_delay);
1056 Track::monitoring_changed (bool, Controllable::GroupControlDisposition)
1058 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1059 (*i)->monitoring_changed ();
1064 Track::metering_state () const
1067 if (_session.transport_rolling ()) {
1068 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1069 rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled());
1071 // track no_roll() always metering if
1072 rv = _meter_point == MeterInput;
1074 return rv ? MeteringInput : MeteringRoute;