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/record_enable_control.h"
31 #include "ardour/record_safe_control.h"
32 #include "ardour/route_group_specialized.h"
33 #include "ardour/session.h"
34 #include "ardour/session_playlists.h"
35 #include "ardour/track.h"
36 #include "ardour/utils.h"
41 using namespace ARDOUR;
44 Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode mode, DataType default_type)
45 : Route (sess, name, flag, default_type)
46 , _saved_meter_point (_meter_point)
49 _freeze_record.state = NoFreeze;
55 DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
65 boost::shared_ptr<Route> rp (shared_from_this());
66 boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
68 _record_enable_control.reset (new RecordEnableControl (_session, X_("recenable"), *this));
69 add_control (_record_enable_control);
71 _record_safe_control.reset (new RecordSafeControl (_session, X_("recsafe"), *this));
72 add_control (_record_safe_control);
74 _monitoring_control.reset (new MonitorControl (_session, X_("monitoring"), *this));
75 add_control (_monitoring_control);
77 _session.config.ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
79 _monitoring_control->Changed.connect_same_thread (*this, boost::bind (&Track::monitoring_changed, this, _1, _2));
80 _record_safe_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_safe_changed, this, _1, _2));
81 _record_enable_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_enable_changed, this, _1, _2));
87 Track::use_new_diskstream ()
89 boost::shared_ptr<Diskstream> ds = create_diskstream ();
91 ds->do_refill_with_alloc ();
92 ds->set_block_size (_session.get_block_size ());
93 ds->playlist()->set_orig_track_id (id());
105 Track::state (bool full)
107 XMLNode& root (Route::state (full));
109 root.add_child_nocopy (_monitoring_control->get_state ());
110 root.add_child_nocopy (_record_safe_control->get_state ());
111 root.add_child_nocopy (_record_enable_control->get_state ());
113 root.add_property (X_("saved-meter-point"), enum_2_string (_saved_meter_point));
114 root.add_child_nocopy (_diskstream->get_state ());
120 Track::set_state (const XMLNode& node, int version)
122 if (Route::set_state (node, version)) {
128 if (version >= 3000) {
129 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
130 boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
131 ds->do_refill_with_alloc ();
137 _diskstream->playlist()->set_orig_track_id (id());
140 /* set rec-enable control *AFTER* setting up diskstream, because it may
141 want to operate on the diskstream as it sets its own state
144 XMLNodeList nlist = node.children();
145 for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
148 XMLProperty const * prop;
150 if (child->name() == Controllable::xml_node_name) {
151 if ((prop = child->property ("name")) == 0) {
155 if (prop->value() == _record_enable_control->name()) {
156 _record_enable_control->set_state (*child, version);
157 } else if (prop->value() == _record_safe_control->name()) {
158 _record_safe_control->set_state (*child, version);
159 } else if (prop->value() == _monitoring_control->name()) {
160 _monitoring_control->set_state (*child, version);
165 XMLProperty const * prop;
167 if ((prop = node.property (X_("saved-meter-point"))) != 0) {
168 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
170 _saved_meter_point = _meter_point;
177 Track::get_template ()
179 return state (false);
182 Track::FreezeRecord::~FreezeRecord ()
184 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
190 Track::freeze_state() const
192 return _freeze_record.state;
198 bool will_record = true;
199 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
208 Track::prep_record_enabled (bool yn)
210 if (yn && _record_safe_control->get_value()) {
214 if (!can_be_record_enabled()) {
218 /* keep track of the meter point as it was before we rec-enabled */
219 if (!_diskstream->record_enabled()) {
220 _saved_meter_point = _meter_point;
226 will_follow = _diskstream->prep_record_enable ();
228 will_follow = _diskstream->prep_record_disable ();
233 if (_meter_point != MeterCustom) {
234 set_meter_point (MeterInput);
237 set_meter_point (_saved_meter_point);
245 Track::record_enable_changed (bool, Controllable::GroupControlDisposition)
247 _diskstream->set_record_enabled (_record_enable_control->get_value());
251 Track::record_safe_changed (bool, Controllable::GroupControlDisposition)
253 _diskstream->set_record_safe (_record_safe_control->get_value());
257 Track::can_be_record_safe ()
259 return !_record_enable_control->get_value() && _diskstream && _session.writable() && (_freeze_record.state != Frozen);
263 Track::can_be_record_enabled ()
265 return !_record_safe_control->get_value() && _diskstream && !_diskstream->record_safe() && _session.writable() && (_freeze_record.state != Frozen);
269 Track::parameter_changed (string const & p)
271 if (p == "track-name-number") {
272 resync_track_name ();
274 else if (p == "track-name-take") {
275 resync_track_name ();
277 else if (p == "take-name") {
278 if (_session.config.get_track_name_take()) {
279 resync_track_name ();
285 Track::resync_track_name ()
291 Track::set_name (const string& str)
295 if (_record_enable_control->get_value() && _session.actively_recording()) {
296 /* this messes things up if done while recording */
300 string diskstream_name = "";
301 if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
302 // Note: any text is fine, legalize_for_path() fixes this later
303 diskstream_name += _session.config.get_take_name ();
304 diskstream_name += "_";
306 const int64_t tracknumber = track_number();
307 if (tracknumber > 0 && _session.config.get_track_name_number()) {
308 char num[64], fmt[10];
309 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
310 snprintf(num, sizeof(num), fmt, tracknumber);
311 diskstream_name += num;
312 diskstream_name += "_";
314 diskstream_name += str;
316 if (diskstream_name == _diskstream_name) {
319 _diskstream_name = diskstream_name;
321 _diskstream->set_write_source_name (diskstream_name);
323 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
324 if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
325 /* Only rename the diskstream (and therefore the playlist) if
326 a) the playlist has never had a region added to it and
327 b) there is only one playlist for this track.
329 If (a) is not followed, people can get confused if, say,
330 they have notes about a playlist with a given name and then
331 it changes (see mantis #4759).
333 If (b) is not followed, we rename the current playlist and not
334 the other ones, which is a bit confusing (see mantis #4977).
336 _diskstream->set_name (str);
339 /* save state so that the statefile fully reflects any filename changes */
341 if ((ret = Route::set_name (str)) == 0) {
342 _session.save_state ("");
349 Track::set_latency_compensation (framecnt_t longest_session_latency)
351 Route::set_latency_compensation (longest_session_latency);
352 _diskstream->set_roll_delay (_roll_delay);
356 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
358 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
364 bool can_record = _session.actively_recording ();
366 /* no outputs? nothing to do ... what happens if we have sends etc. ? */
368 if (n_outputs().n_total() == 0) {
372 /* not active ... do the minimum possible by just outputting silence */
376 if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled())) {
382 if (session_state_changing) {
383 if (_session.transport_speed() != 0.0f) {
384 /* we're rolling but some state is changing (e.g. our diskstream contents)
385 so we cannot use them. Be silent till this is over. Don't declick.
387 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
389 passthru_silence (start_frame, end_frame, nframes, 0);
392 /* we're really not rolling, so we're either delivery silence or actually
393 monitoring, both of which are safe to do while session_state_changing is true.
397 _diskstream->check_record_status (start_frame, can_record);
401 MonitorState const s = monitoring_state ();
402 /* we are not rolling, so be silent even if we are monitoring disk, as there
403 will be no disk data coming in.
406 case MonitoringSilence:
412 case MonitoringInput:
420 //if we have an internal generator, let it play regardless of monitoring state
421 if (_have_internal_generator) {
425 _amp->apply_gain_automation (false);
427 /* if have_internal_generator, or .. */
431 if (_meter_point == MeterInput) {
432 /* still need input monitoring and metering */
434 bool const track_rec = _diskstream->record_enabled ();
435 bool const auto_input = _session.config.get_auto_input ();
436 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
437 bool const tape_machine_mode = Config->get_tape_machine_mode ();
438 bool no_meter = false;
440 /* this needs a proper K-map
441 * and should be separated into a function similar to monitoring_state()
442 * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
444 * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
446 if (!auto_input && !track_rec) {
449 else if (tape_machine_mode && !track_rec && auto_input) {
452 else if (!software_monitor && tape_machine_mode && !track_rec) {
455 else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
460 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
461 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
462 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, speed(), nframes);
464 _input->process_input (_meter, start_frame, end_frame, speed(), nframes);
468 passthru_silence (start_frame, end_frame, nframes, 0);
472 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
474 fill_buffers_with_input (bufs, _input, nframes);
476 if (_meter_point == MeterInput) {
477 _meter->run (bufs, start_frame, end_frame, 1.0 /*speed()*/, nframes, true);
480 passthru (bufs, start_frame, end_frame, nframes, false);
483 flush_processor_buffers_locked (nframes);
489 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
491 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
493 framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
494 if (can_internal_playback_seek(playback_distance)) {
495 internal_playback_seek(playback_distance);
500 if (n_outputs().n_total() == 0 && _processors.empty()) {
510 _amp->apply_gain_automation(false);
513 flush_processor_buffers_locked (nframes);
515 framecnt_t playback_distance;
517 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
519 int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
520 need_butler = _diskstream->commit (playback_distance);
525 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
529 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
530 diskstream_playlist_changed ();
531 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
532 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
536 Track::diskstream_playlist_changed ()
538 PlaylistChanged (); /* EMIT SIGNAL */
542 Track::diskstream_speed_changed ()
544 SpeedChanged (); /* EMIT SIGNAL */
548 Track::diskstream_alignment_style_changed ()
550 AlignmentStyleChanged (); /* EMIT SIGNAL */
553 boost::shared_ptr<Playlist>
556 return _diskstream->playlist ();
560 Track::request_input_monitoring (bool m)
562 _diskstream->request_input_monitoring (m);
566 Track::ensure_input_monitoring (bool m)
568 _diskstream->ensure_input_monitoring (m);
572 Track::destructive () const
574 return _diskstream->destructive ();
577 list<boost::shared_ptr<Source> > &
578 Track::last_capture_sources ()
580 return _diskstream->last_capture_sources ();
584 Track::set_capture_offset ()
586 _diskstream->set_capture_offset ();
590 Track::steal_write_source_name()
592 return _diskstream->steal_write_source_name ();
596 Track::reset_write_sources (bool r, bool force)
598 _diskstream->reset_write_sources (r, force);
602 Track::playback_buffer_load () const
604 return _diskstream->playback_buffer_load ();
608 Track::capture_buffer_load () const
610 return _diskstream->capture_buffer_load ();
616 return _diskstream->do_refill ();
620 Track::do_flush (RunContext c, bool force)
622 return _diskstream->do_flush (c, force);
626 Track::set_pending_overwrite (bool o)
628 _diskstream->set_pending_overwrite (o);
632 Track::seek (framepos_t p, bool complete_refill)
634 return _diskstream->seek (p, complete_refill);
638 Track::hidden () const
640 return _diskstream->hidden ();
644 Track::can_internal_playback_seek (framecnt_t p)
646 return _diskstream->can_internal_playback_seek (p);
650 Track::internal_playback_seek (framecnt_t p)
652 return _diskstream->internal_playback_seek (p);
656 Track::non_realtime_input_change ()
658 _diskstream->non_realtime_input_change ();
662 Track::non_realtime_locate (framepos_t p)
664 Route::non_realtime_locate (p);
667 /* don't waste i/o cycles and butler calls
668 for hidden (secret) tracks
670 _diskstream->non_realtime_locate (p);
675 Track::non_realtime_set_speed ()
677 _diskstream->non_realtime_set_speed ();
681 Track::overwrite_existing_buffers ()
683 return _diskstream->overwrite_existing_buffers ();
687 Track::get_captured_frames (uint32_t n) const
689 return _diskstream->get_captured_frames (n);
693 Track::set_loop (Location* l)
695 return _diskstream->set_loop (l);
699 Track::transport_looped (framepos_t p)
701 _diskstream->transport_looped (p);
705 Track::realtime_set_speed (double s, bool g)
707 return _diskstream->realtime_set_speed (s, g);
711 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
713 _diskstream->transport_stopped_wallclock (n, t, g);
717 Track::pending_overwrite () const
719 return _diskstream->pending_overwrite ();
723 Track::speed () const
725 return _diskstream->speed ();
729 Track::prepare_to_stop (framepos_t t, framepos_t a)
731 _diskstream->prepare_to_stop (t, a);
735 Track::set_slaved (bool s)
737 _diskstream->set_slaved (s);
743 return _diskstream->n_channels ();
747 Track::get_capture_start_frame (uint32_t n) const
749 return _diskstream->get_capture_start_frame (n);
753 Track::alignment_style () const
755 return _diskstream->alignment_style ();
759 Track::alignment_choice () const
761 return _diskstream->alignment_choice ();
765 Track::current_capture_start () const
767 return _diskstream->current_capture_start ();
771 Track::current_capture_end () const
773 return _diskstream->current_capture_end ();
777 Track::playlist_modified ()
779 _diskstream->playlist_modified ();
783 Track::use_playlist (boost::shared_ptr<Playlist> p)
785 int ret = _diskstream->use_playlist (p);
787 p->set_orig_track_id (id());
793 Track::use_copy_playlist ()
795 int ret = _diskstream->use_copy_playlist ();
798 _diskstream->playlist()->set_orig_track_id (id());
805 Track::use_new_playlist ()
807 int ret = _diskstream->use_new_playlist ();
810 _diskstream->playlist()->set_orig_track_id (id());
817 Track::set_align_style (AlignStyle s, bool force)
819 _diskstream->set_align_style (s, force);
823 Track::set_align_choice (AlignChoice s, bool force)
825 _diskstream->set_align_choice (s, force);
829 Track::using_diskstream_id (PBD::ID id) const
831 return (id == _diskstream->id ());
835 Track::set_block_size (pframes_t n)
837 Route::set_block_size (n);
838 _diskstream->set_block_size (n);
842 Track::adjust_playback_buffering ()
845 _diskstream->adjust_playback_buffering ();
850 Track::adjust_capture_buffering ()
853 _diskstream->adjust_capture_buffering ();
857 #ifdef USE_TRACKS_CODE_FEATURES
859 /* This is the Tracks version of Track::monitoring_state().
861 * Ardour developers: try to flag or fix issues if parts of the libardour API
862 * change in ways that invalidate this
866 Track::monitoring_state () const
868 /* Explicit requests */
870 if (_monitoring & MonitorInput) {
871 return MonitoringInput;
874 if (_monitoring & MonitorDisk) {
875 return MonitoringDisk;
878 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
879 I don't think it's ever going to be too pretty too look at.
882 // GZ: NOT USED IN TRACKS
883 //bool const auto_input = _session.config.get_auto_input ();
884 //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
885 //bool const tape_machine_mode = Config->get_tape_machine_mode ();
887 bool const roll = _session.transport_rolling ();
888 bool const track_rec = _diskstream->record_enabled ();
889 bool session_rec = _session.actively_recording ();
893 if (!session_rec && roll) {
894 return MonitoringDisk;
896 return MonitoringInput;
902 return MonitoringDisk;
906 return MonitoringSilence;
911 /* This is the Ardour/Mixbus version of Track::monitoring_state().
913 * Tracks developers: do NOT modify this method under any circumstances.
917 Track::monitoring_state () const
919 /* Explicit requests */
920 MonitorChoice m (_monitoring_control->monitoring_choice());
922 if (m & MonitorInput) {
923 return MonitoringInput;
926 if (m & MonitorDisk) {
927 return MonitoringDisk;
930 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
931 I don't think it's ever going to be too pretty too look at.
934 bool const roll = _session.transport_rolling ();
935 bool const track_rec = _diskstream->record_enabled ();
936 bool const auto_input = _session.config.get_auto_input ();
937 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
938 bool const tape_machine_mode = Config->get_tape_machine_mode ();
941 /* I suspect that just use actively_recording() is good enough all the
942 * time, but just to keep the semantics the same as they were before
943 * sept 26th 2012, we differentiate between the cases where punch is
944 * enabled and those where it is not.
947 if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
948 session_rec = _session.actively_recording ();
950 session_rec = _session.get_record_enabled();
955 if (!session_rec && roll && auto_input) {
956 return MonitoringDisk;
958 return software_monitor ? MonitoringInput : MonitoringSilence;
963 if (tape_machine_mode) {
965 return MonitoringDisk;
969 if (!roll && auto_input) {
970 return software_monitor ? MonitoringInput : MonitoringSilence;
972 return MonitoringDisk;
978 abort(); /* NOTREACHED */
979 return MonitoringSilence;
985 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
987 /* never declick if there is an internal generator - we just want it to
988 keep generating sound without interruption.
990 ditto if we are monitoring inputs.
993 if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) {
998 declick = _pending_declick;
1002 Amp::declick (bufs, nframes, declick);
1007 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
1009 if (_roll_delay > nframes) {
1011 _roll_delay -= nframes;
1012 silence_unlocked (nframes);
1013 /* transport frame is not legal for caller to use */
1016 } else if (_roll_delay > 0) {
1018 nframes -= _roll_delay;
1019 silence_unlocked (_roll_delay);
1020 transport_frame += _roll_delay;
1022 /* shuffle all the port buffers for things that lead "out" of this Route
1023 to reflect that we just wrote _roll_delay frames of silence.
1026 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1027 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1028 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1030 iop->increment_port_buffer_offset (_roll_delay);
1033 _output->increment_port_buffer_offset (_roll_delay);
1043 Track::monitoring_changed (bool, Controllable::GroupControlDisposition)
1045 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1046 (*i)->monitoring_changed ();
1051 Track::metering_state () const
1054 if (_session.transport_rolling ()) {
1055 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1056 rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled());
1058 // track no_roll() always metering if
1059 rv = _meter_point == MeterInput;
1061 return rv ? MeteringInput : MeteringRoute;