Clean up and hopefully fix handling of logarithmic plugin parameters (fixes #3769).
[ardour.git] / libs / ardour / track.cc
1 /*
2     Copyright (C) 2006 Paul Davis
3
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.
8
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.
13
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.
17 */
18 #include "pbd/error.h"
19
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"
35
36 #include "i18n.h"
37
38 using namespace std;
39 using namespace ARDOUR;
40 using namespace PBD;
41
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)
45         , _mode (mode)
46         , _rec_enable_control (new RecEnableControllable(*this))
47 {
48         _freeze_record.state = NoFreeze;
49         _declickable = true;
50 }
51
52 Track::~Track ()
53 {
54         DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
55 }
56
57 int
58 Track::init ()
59 {
60         if (Route::init ()) {
61                 return -1;
62         }
63
64         return 0;
65 }
66 XMLNode&
67 Track::get_state ()
68 {
69         return state (true);
70 }
71
72
73
74 XMLNode&
75 Track::get_template ()
76 {
77         return state (false);
78 }
79
80 void
81 Track::toggle_monitor_input ()
82 {
83         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
84                 i->ensure_monitor_input(!i->monitoring_input());
85         }
86 }
87
88 ARDOUR::framecnt_t
89 Track::update_total_latency ()
90 {
91         framecnt_t old = _output->effective_latency();
92         framecnt_t own_latency = _output->user_latency();
93
94         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
95                 if ((*i)->active ()) {
96                         own_latency += (*i)->signal_latency ();
97                 }
98         }
99
100 #undef DEBUG_LATENCY
101 #ifdef DEBUG_LATENCY
102         cerr << _name << ": internal redirect (final) latency = " << own_latency << endl;
103 #endif
104
105         _output->set_port_latency (own_latency);
106
107         if (old != own_latency) {
108                 _output->set_latency_delay (own_latency);
109                 signal_latency_changed (); /* EMIT SIGNAL */
110         }
111
112         return _output->effective_latency();
113 }
114
115 Track::FreezeRecord::~FreezeRecord ()
116 {
117         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
118                 delete *i;
119         }
120 }
121
122 Track::FreezeState
123 Track::freeze_state() const
124 {
125         return _freeze_record.state;
126 }
127
128 Track::RecEnableControllable::RecEnableControllable (Track& s)
129         : Controllable (X_("recenable")), track (s)
130 {
131 }
132
133 void
134 Track::RecEnableControllable::set_value (double val)
135 {
136         bool bval = ((val >= 0.5) ? true: false);
137         track.set_record_enabled (bval, this);
138 }
139
140 double
141 Track::RecEnableControllable::get_value (void) const
142 {
143         if (track.record_enabled()) { return 1.0; }
144         return 0.0;
145 }
146
147 bool
148 Track::record_enabled () const
149 {
150         return _diskstream && _diskstream->record_enabled ();
151 }
152
153 bool
154 Track::can_record()
155 {
156         bool will_record = true;
157         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
158                 if (!i->connected())
159                         will_record = false;
160         }
161
162         return will_record;
163 }
164
165 void
166 Track::set_record_enabled (bool yn, void *src)
167 {
168         if (!_session.writable()) {
169                 return;
170         }
171
172         if (_freeze_record.state == Frozen) {
173                 return;
174         }
175
176         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
177                 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
178                 return;
179         }
180
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;
184         }
185
186         _diskstream->set_record_enabled (yn);
187
188         if (_diskstream->record_enabled()) {
189                 if (_meter_point != MeterCustom) {
190                         set_meter_point (MeterInput);
191                 }
192         } else {
193                 set_meter_point (_saved_meter_point);
194         }
195
196         _rec_enable_control->Changed ();
197 }
198
199
200 bool
201 Track::set_name (const string& str)
202 {
203         bool ret;
204
205         if (record_enabled() && _session.actively_recording()) {
206                 /* this messes things up if done while recording */
207                 return false;
208         }
209
210         if (_diskstream->set_name (str)) {
211                 return false;
212         }
213
214         /* save state so that the statefile fully reflects any filename changes */
215
216         if ((ret = Route::set_name (str)) == 0) {
217                 _session.save_state ("");
218         }
219
220         return ret;
221 }
222
223 void
224 Track::set_latency_delay (framecnt_t longest_session_latency)
225 {
226         Route::set_latency_delay (longest_session_latency);
227         _diskstream->set_roll_delay (_roll_delay);
228 }
229
230 void
231 Track::zero_diskstream_id_in_xml (XMLNode& node)
232 {
233         if (node.property ("diskstream-id")) {
234                 node.add_property ("diskstream-id", "0");
235         }
236 }
237
238 int
239 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
240                 bool session_state_changing, bool can_record, bool /*rec_monitors_input*/)
241 {
242         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
243         if (!lm.locked()) {
244                 return 0;
245         }
246
247         if (n_outputs().n_total() == 0) {
248                 return 0;
249         }
250
251         if (!_active) {
252                 silence (nframes);
253                 return 0;
254         }
255
256         if (session_state_changing) {
257                 if (_session.transport_speed() != 0.0f) {
258                         /* we're rolling but some state is changing (e.g. our diskstream contents)
259                            so we cannot use them. Be silent till this is over. Don't declick.
260
261                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
262                         */
263                         passthru_silence (start_frame, end_frame, nframes, 0);
264                         return 0;
265                 }
266                 /* we're really not rolling, so we're either delivery silence or actually
267                    monitoring, both of which are safe to do while session_state_changing is true.
268                 */
269         }
270
271         _diskstream->check_record_status (start_frame, can_record);
272
273         bool send_silence;
274
275         if (_have_internal_generator) {
276                 /* since the instrument has no input streams,
277                    there is no reason to send any signal
278                    into the route.
279                 */
280                 send_silence = true;
281         } else {
282                 if (!Config->get_tape_machine_mode()) {
283                         /*
284                            ADATs work in a strange way..
285                            they monitor input always when stopped.and auto-input is engaged.
286                         */
287                         if ((Config->get_monitoring_model() == SoftwareMonitoring)
288                                         && (_session.config.get_auto_input () || _diskstream->record_enabled())) {
289                                 send_silence = false;
290                         } else {
291                                 send_silence = true;
292                         }
293                 } else {
294                         /*
295                            Other machines switch to input on stop if the track is record enabled,
296                            regardless of the auto input setting (auto input only changes the
297                            monitoring state when the transport is rolling)
298                         */
299                         if ((Config->get_monitoring_model() == SoftwareMonitoring)
300                                         && _diskstream->record_enabled()) {
301                                 send_silence = false;
302                         } else {
303                                 send_silence = true;
304                         }
305                 }
306         }
307
308         _amp->apply_gain_automation(false);
309
310         if (send_silence) {
311
312                 /* if we're sending silence, but we want the meters to show levels for the signal,
313                    meter right here.
314                 */
315
316                 if (_have_internal_generator) {
317                         passthru_silence (start_frame, end_frame, nframes, 0);
318                 } else {
319                         if (_meter_point == MeterInput) {
320                                 _input->process_input (_meter, start_frame, end_frame, nframes);
321                         }
322                         passthru_silence (start_frame, end_frame, nframes, 0);
323                 }
324
325         } else {
326
327                 /* we're sending signal, but we may still want to meter the input.
328                  */
329
330                 passthru (start_frame, end_frame, nframes, false);
331         }
332
333         _main_outs->flush_buffers (nframes, end_frame - start_frame - 1);
334
335         return 0;
336 }
337
338 int
339 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
340                     bool can_record, bool rec_monitors_input, bool& need_butler)
341 {
342         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
343         if (!lm.locked()) {
344                 return 0;
345         }
346
347         if (n_outputs().n_total() == 0 && _processors.empty()) {
348                 return 0;
349         }
350
351         if (!_active) {
352                 silence (nframes);
353                 return 0;
354         }
355
356         _silent = true;
357         _amp->apply_gain_automation(false);
358
359         silence (nframes);
360
361         return _diskstream->process (_session.transport_frame(), nframes, can_record, rec_monitors_input, need_butler);
362 }
363
364 void
365 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
366 {
367         _diskstream = ds;
368         
369         ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
370         diskstream_playlist_changed ();
371         ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
372         ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
373         ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
374 }
375
376 void
377 Track::diskstream_playlist_changed ()
378 {
379         PlaylistChanged (); /* EMIT SIGNAL */
380 }
381
382 void
383 Track::diskstream_record_enable_changed ()
384 {
385         RecordEnableChanged (); /* EMIT SIGNAL */
386 }
387
388 void
389 Track::diskstream_speed_changed ()
390 {
391         SpeedChanged (); /* EMIT SIGNAL */
392 }
393
394 void
395 Track::diskstream_alignment_style_changed ()
396 {
397         AlignmentStyleChanged (); /* EMIT SIGNAL */
398 }
399
400 boost::shared_ptr<Playlist>
401 Track::playlist ()
402 {
403         return _diskstream->playlist ();
404 }
405
406 void
407 Track::monitor_input (bool m)
408 {
409         _diskstream->monitor_input (m);
410 }
411
412 bool
413 Track::destructive () const
414 {
415         return _diskstream->destructive ();
416 }
417
418 list<boost::shared_ptr<Source> > &
419 Track::last_capture_sources ()
420 {
421         return _diskstream->last_capture_sources ();
422 }
423
424 void
425 Track::set_capture_offset ()
426 {
427         _diskstream->set_capture_offset ();
428 }
429
430 list<boost::shared_ptr<Source> > 
431 Track::steal_write_sources()
432 {
433         return _diskstream->steal_write_sources ();
434 }
435
436 void
437 Track::reset_write_sources (bool r, bool force)
438 {
439         _diskstream->reset_write_sources (r, force);
440 }
441
442 float
443 Track::playback_buffer_load () const
444 {
445         return _diskstream->playback_buffer_load ();
446 }
447
448 float
449 Track::capture_buffer_load () const
450 {
451         return _diskstream->capture_buffer_load ();
452 }
453
454 int
455 Track::do_refill ()
456 {
457         return _diskstream->do_refill ();
458 }
459
460 int
461 Track::do_flush (RunContext c, bool force)
462 {
463         return _diskstream->do_flush (c, force);
464 }
465
466 void
467 Track::set_pending_overwrite (bool o)
468 {
469         _diskstream->set_pending_overwrite (o);
470 }
471
472 int
473 Track::seek (framepos_t p, bool complete_refill)
474 {
475         return _diskstream->seek (p, complete_refill);
476 }
477
478 bool
479 Track::hidden () const
480 {
481         return _diskstream->hidden ();
482 }
483
484 int
485 Track::can_internal_playback_seek (framepos_t p)
486 {
487         return _diskstream->can_internal_playback_seek (p);
488 }
489
490 int
491 Track::internal_playback_seek (framepos_t p)
492 {
493         return _diskstream->internal_playback_seek (p);
494 }
495
496 void
497 Track::non_realtime_input_change ()
498 {
499         _diskstream->non_realtime_input_change ();
500 }
501
502 void
503 Track::non_realtime_locate (framepos_t p)
504 {
505         _diskstream->non_realtime_locate (p);
506 }
507
508 void
509 Track::non_realtime_set_speed ()
510 {
511         _diskstream->non_realtime_set_speed ();
512 }
513
514 int
515 Track::overwrite_existing_buffers ()
516 {
517         return _diskstream->overwrite_existing_buffers ();
518 }
519
520 framecnt_t
521 Track::get_captured_frames (uint32_t n) const
522 {
523         return _diskstream->get_captured_frames (n);
524 }
525
526 int
527 Track::set_loop (Location* l)
528 {
529         return _diskstream->set_loop (l);
530 }
531
532 void
533 Track::transport_looped (framepos_t p)
534 {
535         _diskstream->transport_looped (p);
536 }
537
538 bool
539 Track::realtime_set_speed (double s, bool g)
540 {
541         return _diskstream->realtime_set_speed (s, g);
542 }
543
544 void
545 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
546 {
547         _diskstream->transport_stopped_wallclock (n, t, g);
548 }
549
550 bool
551 Track::pending_overwrite () const
552 {
553         return _diskstream->pending_overwrite ();
554 }
555
556 double
557 Track::speed () const
558 {
559         return _diskstream->speed ();
560 }
561
562 void
563 Track::prepare_to_stop (framepos_t p)
564 {
565         _diskstream->prepare_to_stop (p);
566 }
567
568 void
569 Track::set_slaved (bool s)
570 {
571         _diskstream->set_slaved (s);
572 }
573
574 ChanCount
575 Track::n_channels ()
576 {
577         return _diskstream->n_channels ();
578 }
579
580 framepos_t
581 Track::get_capture_start_frame (uint32_t n) const
582 {
583         return _diskstream->get_capture_start_frame (n);
584 }
585
586 AlignStyle
587 Track::alignment_style () const
588 {
589         return _diskstream->alignment_style ();
590 }
591
592 framepos_t
593 Track::current_capture_start () const
594 {
595         return _diskstream->current_capture_start ();
596 }
597
598 framepos_t
599 Track::current_capture_end () const
600 {
601         return _diskstream->current_capture_end ();
602 }
603
604 void
605 Track::playlist_modified ()
606 {
607         _diskstream->playlist_modified ();
608 }
609
610 int
611 Track::use_playlist (boost::shared_ptr<Playlist> p)
612 {
613         return _diskstream->use_playlist (p);
614 }
615
616 int
617 Track::use_copy_playlist ()
618 {
619         return _diskstream->use_copy_playlist ();
620 }
621
622 int
623 Track::use_new_playlist ()
624 {
625         return _diskstream->use_new_playlist ();
626 }
627
628 uint32_t
629 Track::read_data_count () const
630 {
631         return _diskstream->read_data_count ();
632 }
633
634 void
635 Track::set_align_style (AlignStyle s)
636 {
637         _diskstream->set_align_style (s);
638 }
639
640 uint32_t
641 Track::write_data_count () const
642 {
643         return _diskstream->write_data_count ();
644 }
645
646 PBD::ID const &
647 Track::diskstream_id () const
648 {
649         return _diskstream->id ();
650 }
651
652 void
653 Track::set_block_size (pframes_t n)
654 {
655         Route::set_block_size (n);
656         _diskstream->set_block_size (n);
657 }
658
659 void 
660 Track::adjust_playback_buffering ()
661 {
662         if (_diskstream) {
663                 _diskstream->adjust_playback_buffering ();
664         }
665 }
666
667 void 
668 Track::adjust_capture_buffering ()
669 {
670         if (_diskstream) {
671                 _diskstream->adjust_capture_buffering ();
672         }
673 }