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;
50 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
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);
67 _rec_enable_control = boost::shared_ptr<RecEnableControl> (new RecEnableControl(rt));
68 _rec_enable_control->set_flags (Controllable::Toggle);
70 /* don't add rec_enable_control to controls because we don't want it to
71 * appear as an automatable parameter
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 ());
104 if (!_deactivated_processors.empty ()) {
105 XMLNode* node = new XMLNode (X_("DeactivatedProcessors"));
106 for (list<boost::weak_ptr<Processor> >::iterator i = _deactivated_processors.begin(); i != _deactivated_processors.end(); ++i) {
107 boost::shared_ptr<Processor> p = i->lock ();
109 XMLNode* c = new XMLNode (X_("Processor"));
110 c->add_property (X_("id"), p->id().to_s());
111 node->add_child_nocopy (*c);
114 root.add_child_nocopy (*node);
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) {
150 if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
151 if (prop->value() == X_("recenable")) {
152 _rec_enable_control->set_state (*child, version);
156 if (child->name() == X_("DeactivatedProcessors")) {
157 XMLNodeList dp = child->children ();
158 for (XMLNodeConstIterator i = dp.begin(); i != dp.end(); ++i) {
159 assert ((*i)->name() == X_("Processor"));
160 XMLProperty* prop = (*i)->property (X_("id"));
161 boost::shared_ptr<Processor> p = processor_by_id (PBD::ID (prop->value ()));
163 _deactivated_processors.push_back (p);
169 const XMLProperty* prop;
171 if ((prop = node.property (X_("monitoring"))) != 0) {
172 _monitoring = MonitorChoice (string_2_enum (prop->value(), _monitoring));
174 _monitoring = MonitorAuto;
177 if ((prop = node.property (X_("saved-meter-point"))) != 0) {
178 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
180 _saved_meter_point = _meter_point;
187 Track::get_template ()
189 return state (false);
192 Track::FreezeRecord::~FreezeRecord ()
194 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
200 Track::freeze_state() const
202 return _freeze_record.state;
205 Track::RecEnableControl::RecEnableControl (boost::shared_ptr<Track> t)
206 : AutomationControl (t->session(), RecEnableAutomation, boost::shared_ptr<AutomationList>(), X_("recenable"))
209 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(RecEnableAutomation)));
214 Track::RecEnableControl::set_value (double val)
216 boost::shared_ptr<Track> t = track.lock ();
221 t->set_record_enabled (val >= 0.5 ? true : false, this);
225 Track::RecEnableControl::get_value () const
227 boost::shared_ptr<Track> t = track.lock ();
232 return (t->record_enabled() ? 1.0 : 0.0);
236 Track::record_enabled () const
238 return _diskstream && _diskstream->record_enabled ();
244 bool will_record = true;
245 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
253 /* Turn off visible processors (except Fader), keeping track of the old states */
255 Track::deactivate_visible_processors ()
257 _deactivated_processors.clear ();
258 Glib::RWLock::ReaderLock lm (_processor_lock);
260 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
261 if ((*i)->active() && (*i)->display_to_user() && boost::dynamic_pointer_cast<Amp> (*i) == 0) {
263 _deactivated_processors.push_back (*i);
268 /* Turn deactivated processors back on again */
270 Track::activate_deactivated_processors ()
272 for (list<boost::weak_ptr<Processor> >::iterator i = _deactivated_processors.begin(); i != _deactivated_processors.end(); ++i) {
273 boost::shared_ptr<Processor> p = i->lock ();
281 Track::set_record_enabled (bool yn, void *src)
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 /* keep track of the meter point as it was before we rec-enabled */
297 if (!_diskstream->record_enabled()) {
298 _saved_meter_point = _meter_point;
301 if (Config->get_do_not_record_plugins ()) {
303 deactivate_visible_processors ();
305 activate_deactivated_processors ();
309 _diskstream->set_record_enabled (yn);
311 if (_diskstream->record_enabled()) {
312 if (_meter_point != MeterCustom) {
313 set_meter_point (MeterInput);
316 set_meter_point (_saved_meter_point);
319 _rec_enable_control->Changed ();
324 Track::set_name (const string& str)
328 if (record_enabled() && _session.actively_recording()) {
329 /* this messes things up if done while recording */
333 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
334 if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
335 /* Only rename the diskstream (and therefore the playlist) if
336 a) the playlist has never had a region added to it and
337 b) there is only one playlist for this track.
339 If (a) is not followed, people can get confused if, say,
340 they have notes about a playlist with a given name and then
341 it changes (see mantis #4759).
343 If (b) is not followed, we rename the current playlist and not
344 the other ones, which is a bit confusing (see mantis #4977).
346 _diskstream->set_name (str);
349 /* save state so that the statefile fully reflects any filename changes */
351 if ((ret = Route::set_name (str)) == 0) {
352 _session.save_state ("");
359 Track::set_latency_compensation (framecnt_t longest_session_latency)
361 Route::set_latency_compensation (longest_session_latency);
362 _diskstream->set_roll_delay (_roll_delay);
366 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
368 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
373 bool can_record = _session.actively_recording ();
375 if (n_outputs().n_total() == 0) {
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 if (_have_internal_generator) {
404 /* since the instrument has no input streams,
405 there is no reason to send any signal
410 MonitorState const s = monitoring_state ();
411 /* we are not rolling, so be silent even if we are monitoring disk, as there
412 will be no disk data coming in.
414 be_silent = (s == MonitoringSilence || s == MonitoringDisk);
417 if (!_have_internal_generator && metering_state() == MeteringInput) {
418 _input->process_input (_meter, start_frame, end_frame, nframes);
421 _amp->apply_gain_automation(false);
423 /* if have_internal_generator, or .. */
424 //_input->process_input (_meter, start_frame, end_frame, nframes);
428 passthru_silence (start_frame, end_frame, nframes, 0);
432 /* we're sending signal, but we may still want to meter the input.
435 passthru (start_frame, end_frame, nframes, false);
438 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
439 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
441 d->flush_buffers (nframes);
449 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
451 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
456 if (n_outputs().n_total() == 0 && _processors.empty()) {
466 _amp->apply_gain_automation(false);
470 framecnt_t playback_distance;
471 int const dret = _diskstream->process (_session.transport_frame(), nframes, playback_distance);
472 need_butler = _diskstream->commit (playback_distance);
477 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
481 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
482 diskstream_playlist_changed ();
483 ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
484 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
485 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
489 Track::diskstream_playlist_changed ()
491 PlaylistChanged (); /* EMIT SIGNAL */
495 Track::diskstream_record_enable_changed ()
497 RecordEnableChanged (); /* EMIT SIGNAL */
501 Track::diskstream_speed_changed ()
503 SpeedChanged (); /* EMIT SIGNAL */
507 Track::diskstream_alignment_style_changed ()
509 AlignmentStyleChanged (); /* EMIT SIGNAL */
512 boost::shared_ptr<Playlist>
515 return _diskstream->playlist ();
519 Track::request_jack_monitors_input (bool m)
521 _diskstream->request_jack_monitors_input (m);
525 Track::ensure_jack_monitors_input (bool m)
527 _diskstream->ensure_jack_monitors_input (m);
531 Track::destructive () const
533 return _diskstream->destructive ();
536 list<boost::shared_ptr<Source> > &
537 Track::last_capture_sources ()
539 return _diskstream->last_capture_sources ();
543 Track::set_capture_offset ()
545 _diskstream->set_capture_offset ();
548 list<boost::shared_ptr<Source> >
549 Track::steal_write_sources()
551 return _diskstream->steal_write_sources ();
555 Track::reset_write_sources (bool r, bool force)
557 _diskstream->reset_write_sources (r, force);
561 Track::playback_buffer_load () const
563 return _diskstream->playback_buffer_load ();
567 Track::capture_buffer_load () const
569 return _diskstream->capture_buffer_load ();
575 return _diskstream->do_refill ();
579 Track::do_flush (RunContext c, bool force)
581 return _diskstream->do_flush (c, force);
585 Track::set_pending_overwrite (bool o)
587 _diskstream->set_pending_overwrite (o);
591 Track::seek (framepos_t p, bool complete_refill)
593 return _diskstream->seek (p, complete_refill);
597 Track::hidden () const
599 return _diskstream->hidden ();
603 Track::can_internal_playback_seek (framecnt_t p)
605 return _diskstream->can_internal_playback_seek (p);
609 Track::internal_playback_seek (framecnt_t p)
611 return _diskstream->internal_playback_seek (p);
615 Track::non_realtime_input_change ()
617 _diskstream->non_realtime_input_change ();
621 Track::non_realtime_locate (framepos_t p)
623 Route::non_realtime_locate (p);
626 /* don't waste i/o cycles and butler calls
627 for hidden (secret) tracks
629 _diskstream->non_realtime_locate (p);
634 Track::non_realtime_set_speed ()
636 _diskstream->non_realtime_set_speed ();
640 Track::overwrite_existing_buffers ()
642 return _diskstream->overwrite_existing_buffers ();
646 Track::get_captured_frames (uint32_t n) const
648 return _diskstream->get_captured_frames (n);
652 Track::set_loop (Location* l)
654 return _diskstream->set_loop (l);
658 Track::transport_looped (framepos_t p)
660 _diskstream->transport_looped (p);
664 Track::realtime_set_speed (double s, bool g)
666 return _diskstream->realtime_set_speed (s, g);
670 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
672 _diskstream->transport_stopped_wallclock (n, t, g);
676 Track::pending_overwrite () const
678 return _diskstream->pending_overwrite ();
682 Track::speed () const
684 return _diskstream->speed ();
688 Track::prepare_to_stop (framepos_t p)
690 _diskstream->prepare_to_stop (p);
694 Track::set_slaved (bool s)
696 _diskstream->set_slaved (s);
702 return _diskstream->n_channels ();
706 Track::get_capture_start_frame (uint32_t n) const
708 return _diskstream->get_capture_start_frame (n);
712 Track::alignment_style () const
714 return _diskstream->alignment_style ();
718 Track::alignment_choice () const
720 return _diskstream->alignment_choice ();
724 Track::current_capture_start () const
726 return _diskstream->current_capture_start ();
730 Track::current_capture_end () const
732 return _diskstream->current_capture_end ();
736 Track::playlist_modified ()
738 _diskstream->playlist_modified ();
742 Track::use_playlist (boost::shared_ptr<Playlist> p)
744 int ret = _diskstream->use_playlist (p);
746 p->set_orig_track_id (id());
752 Track::use_copy_playlist ()
754 int ret = _diskstream->use_copy_playlist ();
757 _diskstream->playlist()->set_orig_track_id (id());
764 Track::use_new_playlist ()
766 int ret = _diskstream->use_new_playlist ();
769 _diskstream->playlist()->set_orig_track_id (id());
776 Track::set_align_style (AlignStyle s, bool force)
778 _diskstream->set_align_style (s, force);
782 Track::set_align_choice (AlignChoice s, bool force)
784 _diskstream->set_align_choice (s, force);
788 Track::using_diskstream_id (PBD::ID id) const
790 return (id == _diskstream->id ());
794 Track::set_block_size (pframes_t n)
796 Route::set_block_size (n);
797 _diskstream->set_block_size (n);
801 Track::adjust_playback_buffering ()
804 _diskstream->adjust_playback_buffering ();
809 Track::adjust_capture_buffering ()
812 _diskstream->adjust_capture_buffering ();
817 Track::monitoring_state () const
819 /* Explicit requests */
821 if (_monitoring & MonitorInput) {
822 return MonitoringInput;
825 if (_monitoring & MonitorDisk) {
826 return MonitoringDisk;
829 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
830 I don't think it's ever going to be too pretty too look at.
833 bool const roll = _session.transport_rolling ();
834 bool const track_rec = _diskstream->record_enabled ();
835 bool const session_rec = _session.get_record_enabled ();
836 bool const auto_input = _session.config.get_auto_input ();
837 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
838 bool const tape_machine_mode = Config->get_tape_machine_mode ();
842 if (!session_rec && roll && auto_input) {
843 return MonitoringDisk;
845 return software_monitor ? MonitoringInput : MonitoringSilence;
850 if (tape_machine_mode) {
852 return MonitoringDisk;
856 if (!roll && auto_input) {
857 return software_monitor ? MonitoringInput : MonitoringSilence;
859 return MonitoringDisk;
866 return MonitoringSilence;
870 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
872 /* never declick if there is an internal generator - we just want it to
873 keep generating sound without interruption.
875 ditto if we are monitoring inputs.
878 if (_have_internal_generator || monitoring_choice() == MonitorInput) {
883 declick = _pending_declick;
887 Amp::declick (bufs, nframes, declick);
892 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
894 if (_roll_delay > nframes) {
896 _roll_delay -= nframes;
897 silence_unlocked (nframes);
898 /* transport frame is not legal for caller to use */
901 } else if (_roll_delay > 0) {
903 nframes -= _roll_delay;
904 silence_unlocked (_roll_delay);
905 transport_frame += _roll_delay;
907 /* shuffle all the port buffers for things that lead "out" of this Route
908 to reflect that we just wrote _roll_delay frames of silence.
911 Glib::RWLock::ReaderLock lm (_processor_lock);
912 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
913 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
915 iop->increment_port_buffer_offset (_roll_delay);
918 _output->increment_port_buffer_offset (_roll_delay);
928 Track::set_monitoring (MonitorChoice mc)
930 if (mc != _monitoring) {
933 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
934 (*i)->monitoring_changed ();
937 MonitoringChanged (); /* EMIT SIGNAL */
942 Track::parameter_changed (string p)
944 if (p != "do-not-record-plugins") {
948 if (record_enabled ()) {
949 if (Config->get_do_not_record_plugins ()) {
950 deactivate_visible_processors ();
952 activate_deactivated_processors ();
958 Track::metering_state () const
960 return _diskstream->record_enabled() ? MeteringInput : MeteringRoute;