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"
19 #include <sigc++/retype.h>
20 #include <sigc++/retype_return.h>
21 #include <sigc++/bind.h>
23 #include "ardour/amp.h"
24 #include "ardour/audioplaylist.h"
25 #include "ardour/audioregion.h"
26 #include "ardour/audiosource.h"
27 #include "ardour/diskstream.h"
28 #include "ardour/io_processor.h"
29 #include "ardour/meter.h"
30 #include "ardour/port.h"
31 #include "ardour/processor.h"
32 #include "ardour/route_group_specialized.h"
33 #include "ardour/session.h"
34 #include "ardour/track.h"
35 #include "ardour/utils.h"
40 using namespace ARDOUR;
43 Track::Track (Session& sess, string name, Route::Flag flag, TrackMode mode, DataType default_type)
44 : Route (sess, name, flag, default_type)
45 , _rec_enable_control (new RecEnableControllable(*this))
48 _freeze_record.state = NoFreeze;
49 _saved_meter_point = _meter_point;
53 Track::Track (Session& sess, const XMLNode& node, DataType default_type)
54 : Route (sess, node, default_type)
55 , _rec_enable_control (new RecEnableControllable(*this))
57 _freeze_record.state = NoFreeze;
59 _saved_meter_point = _meter_point;
67 Track::set_meter_point (MeterPoint p, void *src)
69 Route::set_meter_point (p, src);
79 Track::get_template ()
85 Track::toggle_monitor_input ()
87 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
88 i->ensure_monitor_input(!i->monitoring_input());
93 Track::update_total_latency ()
95 nframes_t old = _output->effective_latency();
96 nframes_t own_latency = _output->user_latency();
98 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
99 if ((*i)->active ()) {
100 own_latency += (*i)->signal_latency ();
106 cerr << _name << ": internal redirect (final) latency = " << own_latency << endl;
109 _output->set_port_latency (own_latency);
111 if (old != own_latency) {
112 _output->set_latency_delay (own_latency);
113 signal_latency_changed (); /* EMIT SIGNAL */
116 return _output->effective_latency();
119 Track::FreezeRecord::~FreezeRecord ()
121 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
127 Track::freeze_state() const
129 return _freeze_record.state;
132 Track::RecEnableControllable::RecEnableControllable (Track& s)
133 : Controllable (X_("recenable")), track (s)
138 Track::RecEnableControllable::set_value (float val)
140 bool bval = ((val >= 0.5f) ? true: false);
141 track.set_record_enable (bval, this);
145 Track::RecEnableControllable::get_value (void) const
147 if (track.record_enabled()) { return 1.0f; }
152 Track::record_enabled () const
154 return _diskstream && _diskstream->record_enabled ();
160 bool will_record = true;
161 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
170 Track::set_record_enable (bool yn, void *src)
172 if (_freeze_record.state == Frozen) {
176 if (_mix_group && src != _mix_group && _mix_group->is_active()) {
177 _mix_group->apply (&Track::set_record_enable, yn, _mix_group);
181 /* keep track of the meter point as it was before we rec-enabled */
182 if (!_diskstream->record_enabled()) {
183 _saved_meter_point = _meter_point;
186 _diskstream->set_record_enabled (yn);
188 if (_diskstream->record_enabled()) {
189 set_meter_point (MeterInput, this);
191 set_meter_point (_saved_meter_point, this);
194 _rec_enable_control->Changed ();
199 Track::set_name (const string& str)
203 if (record_enabled() && _session.actively_recording()) {
204 /* this messes things up if done while recording */
208 if (_diskstream->set_name (str)) {
212 /* save state so that the statefile fully reflects any filename changes */
214 if ((ret = Route::set_name (str)) == 0) {
215 _session.save_state ("");
222 Track::set_latency_delay (nframes_t longest_session_latency)
224 Route::set_latency_delay (longest_session_latency);
225 _diskstream->set_roll_delay (_roll_delay);
229 Track::zero_diskstream_id_in_xml (XMLNode& node)
231 if (node.property ("diskstream-id")) {
232 node.add_property ("diskstream-id", "0");
237 Track::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
238 bool session_state_changing, bool can_record, bool rec_monitors_input)
240 if (n_outputs().n_total() == 0) {
249 if (session_state_changing) {
251 /* XXX is this safe to do against transport state changes? */
253 passthru_silence (start_frame, end_frame, nframes, 0);
257 diskstream()->check_record_status (start_frame, nframes, can_record);
261 if (_have_internal_generator) {
262 /* since the instrument has no input streams,
263 there is no reason to send any signal
268 if (!Config->get_tape_machine_mode()) {
270 ADATs work in a strange way..
271 they monitor input always when stopped.and auto-input is engaged.
273 if ((Config->get_monitoring_model() == SoftwareMonitoring)
274 && (_session.config.get_auto_input () || _diskstream->record_enabled())) {
275 send_silence = false;
281 Other machines switch to input on stop if the track is record enabled,
282 regardless of the auto input setting (auto input only changes the
283 monitoring state when the transport is rolling)
285 if ((Config->get_monitoring_model() == SoftwareMonitoring)
286 && _diskstream->record_enabled()) {
287 send_silence = false;
294 _amp->apply_gain_automation(false);
298 /* if we're sending silence, but we want the meters to show levels for the signal,
302 if (_have_internal_generator) {
303 passthru_silence (start_frame, end_frame, nframes, 0);
305 if (_meter_point == MeterInput) {
306 _input->process_input (_meter, start_frame, end_frame, nframes);
308 passthru_silence (start_frame, end_frame, nframes, 0);
313 /* we're sending signal, but we may still want to meter the input.
316 passthru (start_frame, end_frame, nframes, false);
323 Track::silent_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
324 bool can_record, bool rec_monitors_input)
326 if (n_outputs().n_total() == 0 && _processors.empty()) {
336 _amp->apply_gain_automation(false);
340 return diskstream()->process (_session.transport_frame(), nframes, can_record, rec_monitors_input);