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(), RecEnableAutomation, boost::shared_ptr<AutomationList>(), X_("recenable"))
184 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(RecEnableAutomation)));
189 Track::RecEnableControl::set_value (double val)
191 boost::shared_ptr<Track> t = track.lock ();
196 t->set_record_enabled (val >= 0.5 ? true : false, this);
200 Track::RecEnableControl::get_value () const
202 boost::shared_ptr<Track> t = track.lock ();
207 return (t->record_enabled() ? 1.0 : 0.0);
211 Track::record_enabled () const
213 return _diskstream && _diskstream->record_enabled ();
219 bool will_record = true;
220 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
229 Track::prep_record_enabled (bool yn, void *src)
231 if (!_session.writable()) {
235 if (_freeze_record.state == Frozen) {
239 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
240 _route_group->apply (&Track::prep_record_enabled, yn, _route_group);
244 /* keep track of the meter point as it was before we rec-enabled */
245 if (!_diskstream->record_enabled()) {
246 _saved_meter_point = _meter_point;
252 will_follow = _diskstream->prep_record_enable ();
254 will_follow = _diskstream->prep_record_disable ();
259 if (_meter_point != MeterCustom) {
260 set_meter_point (MeterInput);
263 set_meter_point (_saved_meter_point);
269 Track::set_record_enabled (bool yn, void *src)
271 if (!_session.writable()) {
275 if (_freeze_record.state == Frozen) {
279 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
280 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
284 _diskstream->set_record_enabled (yn);
286 _rec_enable_control->Changed ();
290 Track::parameter_changed (string const & p)
292 if (p == "track-name-number") {
293 resync_track_name ();
295 else if (p == "track-name-take") {
296 resync_track_name ();
298 else if (p == "take-name") {
299 if (_session.config.get_track_name_take()) {
300 resync_track_name ();
306 Track::resync_track_name ()
312 Track::set_name (const string& str)
316 if (record_enabled() && _session.actively_recording()) {
317 /* this messes things up if done while recording */
321 string diskstream_name = "";
322 if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
323 // Note: any text is fine, legalize_for_path() fixes this later
324 diskstream_name += _session.config.get_take_name ();
325 diskstream_name += "_";
327 const int64_t tracknumber = track_number();
328 if (tracknumber > 0 && _session.config.get_track_name_number()) {
329 char num[64], fmt[10];
330 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
331 snprintf(num, sizeof(num), fmt, tracknumber);
332 diskstream_name += num;
333 diskstream_name += "_";
335 diskstream_name += str;
337 if (diskstream_name == _diskstream_name) {
340 _diskstream_name = diskstream_name;
342 _diskstream->set_write_source_name (diskstream_name);
344 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
345 if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
346 /* Only rename the diskstream (and therefore the playlist) if
347 a) the playlist has never had a region added to it and
348 b) there is only one playlist for this track.
350 If (a) is not followed, people can get confused if, say,
351 they have notes about a playlist with a given name and then
352 it changes (see mantis #4759).
354 If (b) is not followed, we rename the current playlist and not
355 the other ones, which is a bit confusing (see mantis #4977).
357 _diskstream->set_name (str);
360 /* save state so that the statefile fully reflects any filename changes */
362 if ((ret = Route::set_name (str)) == 0) {
363 _session.save_state ("");
370 Track::set_latency_compensation (framecnt_t longest_session_latency)
372 Route::set_latency_compensation (longest_session_latency);
373 _diskstream->set_roll_delay (_roll_delay);
377 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
379 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
385 bool can_record = _session.actively_recording ();
387 /* no outputs? nothing to do ... what happens if we have sends etc. ? */
389 if (n_outputs().n_total() == 0) {
393 /* not active ... do the minimum possible by just outputting silence */
397 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
403 if (session_state_changing) {
404 if (_session.transport_speed() != 0.0f) {
405 /* we're rolling but some state is changing (e.g. our diskstream contents)
406 so we cannot use them. Be silent till this is over. Don't declick.
408 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
410 passthru_silence (start_frame, end_frame, nframes, 0);
413 /* we're really not rolling, so we're either delivery silence or actually
414 monitoring, both of which are safe to do while session_state_changing is true.
418 _diskstream->check_record_status (start_frame, can_record);
422 if (_have_internal_generator) {
423 /* since the instrument has no input streams,
424 there is no reason to send any signal
431 MonitorState const s = monitoring_state ();
432 /* we are not rolling, so be silent even if we are monitoring disk, as there
433 will be no disk data coming in.
436 case MonitoringSilence:
437 /* if there is an instrument, be_silent should always
440 be_silent = (the_instrument_unlocked() == 0);
445 case MonitoringInput:
454 _amp->apply_gain_automation (false);
456 /* if have_internal_generator, or .. */
460 if (_meter_point == MeterInput) {
461 /* still need input monitoring and metering */
463 bool const track_rec = _diskstream->record_enabled ();
464 bool const auto_input = _session.config.get_auto_input ();
465 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
466 bool const tape_machine_mode = Config->get_tape_machine_mode ();
467 bool no_meter = false;
469 /* this needs a proper K-map
470 * and should be separated into a function similar to monitoring_state()
471 * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
473 * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
475 if (!auto_input && !track_rec) {
478 else if (tape_machine_mode && !track_rec && auto_input) {
481 else if (!software_monitor && tape_machine_mode && !track_rec) {
484 else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
489 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
490 _meter->run (bufs, 0, 0, nframes, true);
491 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, nframes);
493 _input->process_input (_meter, start_frame, end_frame, nframes);
497 passthru_silence (start_frame, end_frame, nframes, 0);
501 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
503 fill_buffers_with_input (bufs, _input, nframes);
505 if (_meter_point == MeterInput) {
506 _meter->run (bufs, start_frame, end_frame, nframes, true);
509 passthru (bufs, start_frame, end_frame, nframes, false);
512 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
513 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
515 d->flush_buffers (nframes);
523 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
525 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
527 framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
528 if (can_internal_playback_seek(playback_distance)) {
529 internal_playback_seek(playback_distance);
534 if (n_outputs().n_total() == 0 && _processors.empty()) {
544 _amp->apply_gain_automation(false);
548 framecnt_t playback_distance;
550 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
552 int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
553 need_butler = _diskstream->commit (playback_distance);
558 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
562 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
563 diskstream_playlist_changed ();
564 ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
565 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
566 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
570 Track::diskstream_playlist_changed ()
572 PlaylistChanged (); /* EMIT SIGNAL */
576 Track::diskstream_record_enable_changed ()
578 RecordEnableChanged (); /* EMIT SIGNAL */
582 Track::diskstream_speed_changed ()
584 SpeedChanged (); /* EMIT SIGNAL */
588 Track::diskstream_alignment_style_changed ()
590 AlignmentStyleChanged (); /* EMIT SIGNAL */
593 boost::shared_ptr<Playlist>
596 return _diskstream->playlist ();
600 Track::request_input_monitoring (bool m)
602 _diskstream->request_input_monitoring (m);
606 Track::ensure_input_monitoring (bool m)
608 _diskstream->ensure_input_monitoring (m);
612 Track::destructive () const
614 return _diskstream->destructive ();
617 list<boost::shared_ptr<Source> > &
618 Track::last_capture_sources ()
620 return _diskstream->last_capture_sources ();
624 Track::set_capture_offset ()
626 _diskstream->set_capture_offset ();
630 Track::steal_write_source_name()
632 return _diskstream->steal_write_source_name ();
636 Track::reset_write_sources (bool r, bool force)
638 _diskstream->reset_write_sources (r, force);
642 Track::playback_buffer_load () const
644 return _diskstream->playback_buffer_load ();
648 Track::capture_buffer_load () const
650 return _diskstream->capture_buffer_load ();
656 return _diskstream->do_refill ();
660 Track::do_flush (RunContext c, bool force)
662 return _diskstream->do_flush (c, force);
666 Track::set_pending_overwrite (bool o)
668 _diskstream->set_pending_overwrite (o);
672 Track::seek (framepos_t p, bool complete_refill)
674 return _diskstream->seek (p, complete_refill);
678 Track::hidden () const
680 return _diskstream->hidden ();
684 Track::can_internal_playback_seek (framecnt_t p)
686 return _diskstream->can_internal_playback_seek (p);
690 Track::internal_playback_seek (framecnt_t p)
692 return _diskstream->internal_playback_seek (p);
696 Track::non_realtime_input_change ()
698 _diskstream->non_realtime_input_change ();
702 Track::non_realtime_locate (framepos_t p)
704 Route::non_realtime_locate (p);
707 /* don't waste i/o cycles and butler calls
708 for hidden (secret) tracks
710 _diskstream->non_realtime_locate (p);
715 Track::non_realtime_set_speed ()
717 _diskstream->non_realtime_set_speed ();
721 Track::overwrite_existing_buffers ()
723 return _diskstream->overwrite_existing_buffers ();
727 Track::get_captured_frames (uint32_t n) const
729 return _diskstream->get_captured_frames (n);
733 Track::set_loop (Location* l)
735 return _diskstream->set_loop (l);
739 Track::transport_looped (framepos_t p)
741 _diskstream->transport_looped (p);
745 Track::realtime_set_speed (double s, bool g)
747 return _diskstream->realtime_set_speed (s, g);
751 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
753 _diskstream->transport_stopped_wallclock (n, t, g);
757 Track::pending_overwrite () const
759 return _diskstream->pending_overwrite ();
763 Track::speed () const
765 return _diskstream->speed ();
769 Track::prepare_to_stop (framepos_t p)
771 _diskstream->prepare_to_stop (p);
775 Track::set_slaved (bool s)
777 _diskstream->set_slaved (s);
783 return _diskstream->n_channels ();
787 Track::get_capture_start_frame (uint32_t n) const
789 return _diskstream->get_capture_start_frame (n);
793 Track::alignment_style () const
795 return _diskstream->alignment_style ();
799 Track::alignment_choice () const
801 return _diskstream->alignment_choice ();
805 Track::current_capture_start () const
807 return _diskstream->current_capture_start ();
811 Track::current_capture_end () const
813 return _diskstream->current_capture_end ();
817 Track::playlist_modified ()
819 _diskstream->playlist_modified ();
823 Track::use_playlist (boost::shared_ptr<Playlist> p)
825 int ret = _diskstream->use_playlist (p);
827 p->set_orig_track_id (id());
833 Track::use_copy_playlist ()
835 int ret = _diskstream->use_copy_playlist ();
838 _diskstream->playlist()->set_orig_track_id (id());
845 Track::use_new_playlist ()
847 int ret = _diskstream->use_new_playlist ();
850 _diskstream->playlist()->set_orig_track_id (id());
857 Track::set_align_style (AlignStyle s, bool force)
859 _diskstream->set_align_style (s, force);
863 Track::set_align_choice (AlignChoice s, bool force)
865 _diskstream->set_align_choice (s, force);
869 Track::using_diskstream_id (PBD::ID id) const
871 return (id == _diskstream->id ());
875 Track::set_block_size (pframes_t n)
877 Route::set_block_size (n);
878 _diskstream->set_block_size (n);
882 Track::adjust_playback_buffering ()
885 _diskstream->adjust_playback_buffering ();
890 Track::adjust_capture_buffering ()
893 _diskstream->adjust_capture_buffering ();
898 Track::monitoring_state () const
900 /* Explicit requests */
902 if (_monitoring & MonitorInput) {
903 return MonitoringInput;
906 if (_monitoring & MonitorDisk) {
907 return MonitoringDisk;
910 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
911 I don't think it's ever going to be too pretty too look at.
914 bool const roll = _session.transport_rolling ();
915 bool const track_rec = _diskstream->record_enabled ();
916 bool const auto_input = _session.config.get_auto_input ();
917 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
918 bool const tape_machine_mode = Config->get_tape_machine_mode ();
921 /* I suspect that just use actively_recording() is good enough all the
922 * time, but just to keep the semantics the same as they were before
923 * sept 26th 2012, we differentiate between the cases where punch is
924 * enabled and those where it is not.
927 if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
928 session_rec = _session.actively_recording ();
930 session_rec = _session.get_record_enabled();
935 if (!session_rec && roll && auto_input) {
936 return MonitoringDisk;
938 return software_monitor ? MonitoringInput : MonitoringSilence;
943 if (tape_machine_mode) {
945 return MonitoringDisk;
949 if (!roll && auto_input) {
950 return software_monitor ? MonitoringInput : MonitoringSilence;
952 return MonitoringDisk;
959 return MonitoringSilence;
963 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
965 /* never declick if there is an internal generator - we just want it to
966 keep generating sound without interruption.
968 ditto if we are monitoring inputs.
971 if (_have_internal_generator || monitoring_choice() == MonitorInput) {
976 declick = _pending_declick;
980 Amp::declick (bufs, nframes, declick);
985 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
987 if (_roll_delay > nframes) {
989 _roll_delay -= nframes;
990 silence_unlocked (nframes);
991 /* transport frame is not legal for caller to use */
994 } else if (_roll_delay > 0) {
996 nframes -= _roll_delay;
997 silence_unlocked (_roll_delay);
998 transport_frame += _roll_delay;
1000 /* shuffle all the port buffers for things that lead "out" of this Route
1001 to reflect that we just wrote _roll_delay frames of silence.
1004 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1005 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1006 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1008 iop->increment_port_buffer_offset (_roll_delay);
1011 _output->increment_port_buffer_offset (_roll_delay);
1021 Track::set_monitoring (MonitorChoice mc)
1023 if (mc != _monitoring) {
1026 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1027 (*i)->monitoring_changed ();
1030 MonitoringChanged (); /* EMIT SIGNAL */
1035 Track::metering_state () const
1038 if (_session.transport_rolling ()) {
1039 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1040 rv = _meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled());
1042 // track no_roll() always metering if
1043 rv = _meter_point == MeterInput;
1045 return rv ? MeteringInput : MeteringRoute;