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/audioplaylist.h"
22 #include "ardour/audioregion.h"
23 #include "ardour/audiosource.h"
24 #include "ardour/debug.h"
25 #include "ardour/delivery.h"
26 #include "ardour/diskstream.h"
27 #include "ardour/io_processor.h"
28 #include "ardour/meter.h"
29 #include "ardour/port.h"
30 #include "ardour/processor.h"
31 #include "ardour/route_group_specialized.h"
32 #include "ardour/session.h"
33 #include "ardour/track.h"
34 #include "ardour/utils.h"
39 using namespace ARDOUR;
42 Track::Track (Session& sess, string name, Route::Flag flag, TrackMode mode, DataType default_type)
43 : Route (sess, name, flag, default_type)
44 , _saved_meter_point (_meter_point)
46 , _monitoring (MonitorAuto)
47 , _rec_enable_control (new RecEnableControllable(*this))
49 _freeze_record.state = NoFreeze;
55 DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
75 Track::state (bool full)
77 XMLNode& root (Route::state (full));
78 root.add_property (X_("monitoring"), enum_2_string (_monitoring));
79 root.add_property (X_("saved-meter-point"), enum_2_string (_saved_meter_point));
80 root.add_child_nocopy (_rec_enable_control->get_state());
81 root.add_child_nocopy (_diskstream->get_state ());
86 Track::set_state (const XMLNode& node, int version)
88 if (Route::set_state (node, version)) {
94 if (version >= 3000) {
95 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
96 boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
97 ds->do_refill_with_alloc ();
102 /* set rec-enable control *AFTER* setting up diskstream, because it may
103 want to operate on the diskstream as it sets its own state
106 XMLNodeList nlist = node.children();
107 for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
111 if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
112 if (prop->value() == X_("recenable")) {
113 _rec_enable_control->set_state (*child, version);
118 const XMLProperty* prop;
120 if ((prop = node.property (X_("monitoring"))) != 0) {
121 _monitoring = MonitorChoice (string_2_enum (prop->value(), _monitoring));
123 _monitoring = MonitorAuto;
126 if ((prop = node.property (X_("saved-meter-point"))) != 0) {
127 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
129 _saved_meter_point = _meter_point;
136 Track::get_template ()
138 return state (false);
142 Track::toggle_monitor_input ()
144 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
145 i->ensure_monitor_input(!i->monitoring_input());
149 Track::FreezeRecord::~FreezeRecord ()
151 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
157 Track::freeze_state() const
159 return _freeze_record.state;
162 Track::RecEnableControllable::RecEnableControllable (Track& s)
163 : Controllable (X_("recenable")), track (s)
168 Track::RecEnableControllable::set_value (double val)
170 bool bval = ((val >= 0.5) ? true: false);
171 track.set_record_enabled (bval, this);
175 Track::RecEnableControllable::get_value (void) const
177 if (track.record_enabled()) { return 1.0; }
182 Track::record_enabled () const
184 return _diskstream && _diskstream->record_enabled ();
190 bool will_record = true;
191 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
200 Track::set_record_enabled (bool yn, void *src)
202 if (!_session.writable()) {
206 if (_freeze_record.state == Frozen) {
210 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
211 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
215 /* keep track of the meter point as it was before we rec-enabled */
216 if (!_diskstream->record_enabled()) {
217 _saved_meter_point = _meter_point;
220 _diskstream->set_record_enabled (yn);
222 if (_diskstream->record_enabled()) {
223 if (_meter_point != MeterCustom) {
224 set_meter_point (MeterInput);
227 set_meter_point (_saved_meter_point);
230 _rec_enable_control->Changed ();
235 Track::set_name (const string& str)
239 if (record_enabled() && _session.actively_recording()) {
240 /* this messes things up if done while recording */
244 _diskstream->set_name (str);
246 /* save state so that the statefile fully reflects any filename changes */
248 if ((ret = Route::set_name (str)) == 0) {
249 _session.save_state ("");
256 Track::set_latency_compensation (framecnt_t longest_session_latency)
258 Route::set_latency_compensation (longest_session_latency);
259 _diskstream->set_roll_delay (_roll_delay);
263 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
265 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
270 bool can_record = _session.actively_recording ();
272 if (n_outputs().n_total() == 0) {
281 if (session_state_changing) {
282 if (_session.transport_speed() != 0.0f) {
283 /* we're rolling but some state is changing (e.g. our diskstream contents)
284 so we cannot use them. Be silent till this is over. Don't declick.
286 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
288 passthru_silence (start_frame, end_frame, nframes, 0);
291 /* we're really not rolling, so we're either delivery silence or actually
292 monitoring, both of which are safe to do while session_state_changing is true.
296 _diskstream->check_record_status (start_frame, can_record);
300 if (_have_internal_generator) {
301 /* since the instrument has no input streams,
302 there is no reason to send any signal
307 be_silent = send_silence ();
310 _amp->apply_gain_automation(false);
314 /* if we're sending silence, but we want the meters to show levels for the signal,
318 if (_have_internal_generator) {
319 passthru_silence (start_frame, end_frame, nframes, 0);
321 if (_meter_point == MeterInput) {
322 _input->process_input (_meter, start_frame, end_frame, nframes);
324 passthru_silence (start_frame, end_frame, nframes, 0);
329 /* we're sending signal, but we may still want to meter the input.
332 passthru (start_frame, end_frame, nframes, false);
335 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
336 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
338 d->flush_buffers (nframes, end_frame - start_frame - 1);
346 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
348 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
353 if (n_outputs().n_total() == 0 && _processors.empty()) {
363 _amp->apply_gain_automation(false);
367 framecnt_t playback_distance;
368 int const dret = _diskstream->process (_session.transport_frame(), nframes, playback_distance);
369 need_butler = _diskstream->commit (playback_distance);
374 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
378 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
379 diskstream_playlist_changed ();
380 ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
381 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
382 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
386 Track::diskstream_playlist_changed ()
388 PlaylistChanged (); /* EMIT SIGNAL */
392 Track::diskstream_record_enable_changed ()
394 RecordEnableChanged (); /* EMIT SIGNAL */
398 Track::diskstream_speed_changed ()
400 SpeedChanged (); /* EMIT SIGNAL */
404 Track::diskstream_alignment_style_changed ()
406 AlignmentStyleChanged (); /* EMIT SIGNAL */
409 boost::shared_ptr<Playlist>
412 return _diskstream->playlist ();
416 Track::monitor_input (bool m)
418 _diskstream->monitor_input (m);
422 Track::destructive () const
424 return _diskstream->destructive ();
427 list<boost::shared_ptr<Source> > &
428 Track::last_capture_sources ()
430 return _diskstream->last_capture_sources ();
434 Track::set_capture_offset ()
436 _diskstream->set_capture_offset ();
439 list<boost::shared_ptr<Source> >
440 Track::steal_write_sources()
442 return _diskstream->steal_write_sources ();
446 Track::reset_write_sources (bool r, bool force)
448 _diskstream->reset_write_sources (r, force);
452 Track::playback_buffer_load () const
454 return _diskstream->playback_buffer_load ();
458 Track::capture_buffer_load () const
460 return _diskstream->capture_buffer_load ();
466 return _diskstream->do_refill ();
470 Track::do_flush (RunContext c, bool force)
472 return _diskstream->do_flush (c, force);
476 Track::set_pending_overwrite (bool o)
478 _diskstream->set_pending_overwrite (o);
482 Track::seek (framepos_t p, bool complete_refill)
484 return _diskstream->seek (p, complete_refill);
488 Track::hidden () const
490 return _diskstream->hidden ();
494 Track::can_internal_playback_seek (framepos_t p)
496 return _diskstream->can_internal_playback_seek (p);
500 Track::internal_playback_seek (framepos_t p)
502 return _diskstream->internal_playback_seek (p);
506 Track::non_realtime_input_change ()
508 _diskstream->non_realtime_input_change ();
512 Track::non_realtime_locate (framepos_t p)
514 _diskstream->non_realtime_locate (p);
518 Track::non_realtime_set_speed ()
520 _diskstream->non_realtime_set_speed ();
524 Track::overwrite_existing_buffers ()
526 return _diskstream->overwrite_existing_buffers ();
530 Track::get_captured_frames (uint32_t n) const
532 return _diskstream->get_captured_frames (n);
536 Track::set_loop (Location* l)
538 return _diskstream->set_loop (l);
542 Track::transport_looped (framepos_t p)
544 _diskstream->transport_looped (p);
548 Track::realtime_set_speed (double s, bool g)
550 return _diskstream->realtime_set_speed (s, g);
554 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
556 _diskstream->transport_stopped_wallclock (n, t, g);
560 Track::pending_overwrite () const
562 return _diskstream->pending_overwrite ();
566 Track::speed () const
568 return _diskstream->speed ();
572 Track::prepare_to_stop (framepos_t p)
574 _diskstream->prepare_to_stop (p);
578 Track::set_slaved (bool s)
580 _diskstream->set_slaved (s);
586 return _diskstream->n_channels ();
590 Track::get_capture_start_frame (uint32_t n) const
592 return _diskstream->get_capture_start_frame (n);
596 Track::alignment_style () const
598 return _diskstream->alignment_style ();
602 Track::alignment_choice () const
604 return _diskstream->alignment_choice ();
608 Track::current_capture_start () const
610 return _diskstream->current_capture_start ();
614 Track::current_capture_end () const
616 return _diskstream->current_capture_end ();
620 Track::playlist_modified ()
622 _diskstream->playlist_modified ();
626 Track::use_playlist (boost::shared_ptr<Playlist> p)
628 return _diskstream->use_playlist (p);
632 Track::use_copy_playlist ()
634 return _diskstream->use_copy_playlist ();
638 Track::use_new_playlist ()
640 return _diskstream->use_new_playlist ();
644 Track::set_align_style (AlignStyle s, bool force)
646 _diskstream->set_align_style (s, force);
650 Track::set_align_choice (AlignChoice s, bool force)
652 _diskstream->set_align_choice (s, force);
656 Track::diskstream_id () const
658 return _diskstream->id ();
662 Track::set_block_size (pframes_t n)
664 Route::set_block_size (n);
665 _diskstream->set_block_size (n);
669 Track::adjust_playback_buffering ()
672 _diskstream->adjust_playback_buffering ();
677 Track::adjust_capture_buffering ()
680 _diskstream->adjust_capture_buffering ();
685 Track::send_silence () const
689 if (Config->get_tape_machine_mode()) {
691 /* ADATs work in a strange way..
692 they monitor input always when stopped.and auto-input is engaged.
695 if ((Config->get_monitoring_model() == SoftwareMonitoring)
696 && ((_monitoring & MonitorInput) || (_diskstream->record_enabled()))) {
697 send_silence = false;
705 /* Other machines switch to input on stop if the track is record enabled,
706 regardless of the auto input setting (auto input only changes the
707 monitoring state when the transport is rolling)
710 if ((Config->get_monitoring_model() == SoftwareMonitoring)
711 && ((_monitoring & MonitorInput) ||
712 (!(_monitoring & MonitorDisk) && (_session.config.get_auto_input () || _diskstream->record_enabled())))){
714 DEBUG_TRACE (DEBUG::Monitor,
715 string_compose ("%1: no roll, use silence = FALSE, monitoring choice %2 recenable %3 sRA %4 autoinput %5\n",
716 name(), enum_2_string (_monitoring),
717 _diskstream->record_enabled(), _session.actively_recording(),
718 _session.config.get_auto_input()));
720 send_silence = false;
722 DEBUG_TRACE (DEBUG::Monitor,
723 string_compose ("%1: no roll, use silence = TRUE, monitoring choice %2 recenable %3 sRA %4 autoinput %5\n",
724 name(), enum_2_string (_monitoring),
725 _diskstream->record_enabled(), _session.actively_recording(),
726 _session.config.get_auto_input()));
735 Track::monitoring_state ()
737 MonitorState ms = MonitoringSilence;
739 if (_session.transport_rolling()) {
743 if (_monitoring & MonitorInput) { // explicitly requested input monitoring
745 ms = MonitoringInput;
747 } else if (_monitoring & MonitorDisk) { // explicitly requested disk monitoring
751 } else if (_diskstream->record_enabled() && _session.actively_recording()) { // Track actually recording
753 ms = MonitoringInput;
755 } else if (_diskstream->record_enabled() && !_session.actively_recording() && _session.config.get_auto_input()) { // Track armed but not recording, with auto input enabled
757 ms = MonitoringInput;
759 } else { // Every other state
769 if (send_silence()) {
771 ms = MonitoringSilence;
774 ms = MonitoringInput;
782 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
784 /* never declick if there is an internal generator - we just want it to
785 keep generating sound without interruption.
787 ditto if we are monitoring inputs.
790 if (_have_internal_generator || monitoring_choice() == MonitorInput) {
795 declick = _pending_declick;
799 Amp::declick (bufs, nframes, declick);
804 Track::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
806 if (_roll_delay > nframes) {
808 _roll_delay -= nframes;
809 silence_unlocked (nframes);
810 /* transport frame is not legal for caller to use */
813 } else if (_roll_delay > 0) {
815 nframes -= _roll_delay;
816 silence_unlocked (_roll_delay);
817 transport_frame += _roll_delay;
819 /* shuffle all the port buffers for things that lead "out" of this Route
820 to reflect that we just wrote _roll_delay frames of silence.
823 Glib::RWLock::ReaderLock lm (_processor_lock);
824 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
825 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
827 iop->increment_port_buffer_offset (_roll_delay);
830 _output->increment_port_buffer_offset (_roll_delay);
840 Track::set_monitoring (MonitorChoice mc)
842 if (mc != _monitoring) {
844 MonitoringChanged (); /* EMIT SIGNAL */