mirror of
https://github.com/Ardour/ardour.git
synced 2026-01-23 13:47:24 +01:00
professionalize peak-meters
The peak meter needs to withstand various test-signals without visual jitter (in particular 1kHz sine) regardless of settings (period-size, sample-rate, custom fall-off). This needs to be done in sync (and not by a random non-rt ‘smoothing’ thread). On the downside this voids the ‘visual smoothing’ particularly with large buffersizes - but then again exactly this “always fall-off no matter what [the next real data will be]” is the problem. One the upside, there’s one less high-frequency (100Hz) thread (Yay!) PS. it probably never worked on windows, anyway. Only peak-meters are affected by his change. K-meters, IEC I/II and VU were never visually smoothed.
This commit is contained in:
Robin Gareus
parent
2f432c3be7
commit
ce259edbcd
8 changed files with 100 additions and 232 deletions
|
|
@ -293,12 +293,6 @@ class LIBARDOUR_API AudioEngine : public SessionHandlePtr, public PortManager
|
|||
void do_reset_backend();
|
||||
void do_devicelist_update();
|
||||
|
||||
void meter_thread ();
|
||||
void start_metering_thread ();
|
||||
void stop_metering_thread ();
|
||||
|
||||
static gint m_meter_exit;
|
||||
|
||||
typedef std::map<std::string,AudioBackendInfo*> BackendMap;
|
||||
BackendMap _backends;
|
||||
AudioBackendInfo* backend_discover (const std::string&);
|
||||
|
|
|
|||
|
|
@ -36,16 +36,6 @@ class BufferSet;
|
|||
class ChanCount;
|
||||
class Session;
|
||||
|
||||
class LIBARDOUR_API Metering {
|
||||
public:
|
||||
static void update_meters ();
|
||||
static PBD::Signal0<void> Meter;
|
||||
|
||||
private:
|
||||
/* this object is not meant to be instantiated */
|
||||
Metering();
|
||||
};
|
||||
|
||||
/** Meters peaks on the input and stores them for access.
|
||||
*/
|
||||
class LIBARDOUR_API PeakMeter : public Processor {
|
||||
|
|
@ -53,7 +43,6 @@ public:
|
|||
PeakMeter(Session& s, const std::string& name);
|
||||
~PeakMeter();
|
||||
|
||||
void meter();
|
||||
void reset ();
|
||||
void reset_max ();
|
||||
|
||||
|
|
@ -64,7 +53,7 @@ public:
|
|||
number of streams in the route, no matter where we put it.
|
||||
*/
|
||||
|
||||
void reset_max_channels (const ChanCount&);
|
||||
void set_max_channels (const ChanCount&);
|
||||
|
||||
/* tell the meter than no matter how many channels it can handle,
|
||||
`in' is the number it is actually going be handling from
|
||||
|
|
@ -83,14 +72,6 @@ public:
|
|||
ChanCount input_streams () const { return current_meters; }
|
||||
ChanCount output_streams () const { return current_meters; }
|
||||
|
||||
float peak_power (uint32_t n) {
|
||||
if (n < _visible_peak_power.size()) {
|
||||
return _visible_peak_power[n];
|
||||
} else {
|
||||
return minus_infinity();
|
||||
}
|
||||
}
|
||||
|
||||
float meter_level (uint32_t n, MeterType type);
|
||||
|
||||
void set_type(MeterType t);
|
||||
|
|
@ -109,10 +90,13 @@ private:
|
|||
*/
|
||||
ChanCount current_meters;
|
||||
|
||||
std::vector<float> _peak_signal;
|
||||
std::vector<float> _visible_peak_power;
|
||||
std::vector<float> _max_peak_signal;
|
||||
std::vector<float> _max_peak_power;
|
||||
bool _reset_dpm;
|
||||
bool _reset_max;
|
||||
|
||||
uint32_t _bufcnt;
|
||||
std::vector<float> _peak_buffer; // internal, integrate
|
||||
std::vector<float> _peak_power; // includes accurate falloff, hence dB
|
||||
std::vector<float> _max_peak_signal; // dB calculation is done on demand
|
||||
|
||||
std::vector<Kmeterdsp *> _kmeter;
|
||||
std::vector<Iec1ppmdsp *> _iec1meter;
|
||||
|
|
|
|||
|
|
@ -185,7 +185,6 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou
|
|||
bool apply_processor_changes_rt ();
|
||||
void emit_pending_signals ();
|
||||
MeterPoint meter_point() const { return _pending_meter_point; }
|
||||
void meter ();
|
||||
|
||||
void set_meter_type (MeterType t) { _meter_type = t; }
|
||||
MeterType meter_type() const { return _meter_type; }
|
||||
|
|
|
|||
|
|
@ -61,7 +61,6 @@ using namespace std;
|
|||
using namespace ARDOUR;
|
||||
using namespace PBD;
|
||||
|
||||
gint AudioEngine::m_meter_exit;
|
||||
AudioEngine* AudioEngine::_instance = 0;
|
||||
|
||||
#ifdef SILENCE_AFTER
|
||||
|
|
@ -99,7 +98,6 @@ AudioEngine::AudioEngine ()
|
|||
, _silence_hit_cnt (0)
|
||||
#endif
|
||||
{
|
||||
g_atomic_int_set (&m_meter_exit, 0);
|
||||
reset_silence_countdown ();
|
||||
start_hw_event_processing();
|
||||
discover_backends ();
|
||||
|
|
@ -108,7 +106,6 @@ AudioEngine::AudioEngine ()
|
|||
AudioEngine::~AudioEngine ()
|
||||
{
|
||||
_in_destructor = true;
|
||||
stop_metering_thread ();
|
||||
stop_hw_event_processing();
|
||||
drop_backend ();
|
||||
for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
|
||||
|
|
@ -571,40 +568,6 @@ AudioEngine::stop_hw_event_processing()
|
|||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
AudioEngine::stop_metering_thread ()
|
||||
{
|
||||
if (m_meter_thread) {
|
||||
g_atomic_int_set (&m_meter_exit, 1);
|
||||
m_meter_thread->join ();
|
||||
m_meter_thread = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
AudioEngine::start_metering_thread ()
|
||||
{
|
||||
if (m_meter_thread == 0) {
|
||||
g_atomic_int_set (&m_meter_exit, 0);
|
||||
m_meter_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::meter_thread, this));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
AudioEngine::meter_thread ()
|
||||
{
|
||||
pthread_set_name (X_("meter"));
|
||||
|
||||
while (true) {
|
||||
Glib::usleep (10000); /* 1/100th sec interval */
|
||||
if (g_atomic_int_get(&m_meter_exit)) {
|
||||
break;
|
||||
}
|
||||
Metering::Meter ();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
AudioEngine::set_session (Session *s)
|
||||
{
|
||||
|
|
@ -664,11 +627,8 @@ AudioEngine::reconnect_session_routes (bool reconnect_inputs, bool reconnect_out
|
|||
void
|
||||
AudioEngine::died ()
|
||||
{
|
||||
/* called from a signal handler for SIGPIPE */
|
||||
|
||||
stop_metering_thread ();
|
||||
|
||||
_running = false;
|
||||
/* called from a signal handler for SIGPIPE */
|
||||
_running = false;
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -877,8 +837,6 @@ AudioEngine::start (bool for_latency)
|
|||
|
||||
}
|
||||
|
||||
start_metering_thread ();
|
||||
|
||||
if (!for_latency) {
|
||||
Running(); /* EMIT SIGNAL */
|
||||
}
|
||||
|
|
@ -911,7 +869,6 @@ AudioEngine::stop (bool for_latency)
|
|||
_latency_output_port = 0;
|
||||
_latency_input_port = 0;
|
||||
_started_for_latency = false;
|
||||
stop_metering_thread ();
|
||||
|
||||
Port::PortDrop ();
|
||||
|
||||
|
|
@ -1252,7 +1209,6 @@ AudioEngine::halted_callback (const char* why)
|
|||
return;
|
||||
}
|
||||
|
||||
stop_metering_thread ();
|
||||
_running = false;
|
||||
|
||||
Port::PortDrop (); /* EMIT SIGNAL */
|
||||
|
|
|
|||
|
|
@ -35,8 +35,6 @@ using namespace std;
|
|||
|
||||
using namespace ARDOUR;
|
||||
|
||||
PBD::Signal0<void> Metering::Meter;
|
||||
|
||||
PeakMeter::PeakMeter (Session& s, const std::string& name)
|
||||
: Processor (s, string_compose ("meter-%1", name))
|
||||
{
|
||||
|
|
@ -46,6 +44,8 @@ PeakMeter::PeakMeter (Session& s, const std::string& name)
|
|||
Vumeterdsp::init(s.nominal_frame_rate());
|
||||
_pending_active = true;
|
||||
_meter_type = MeterPeak;
|
||||
_reset_dpm = true;
|
||||
_reset_max = true;
|
||||
}
|
||||
|
||||
PeakMeter::~PeakMeter ()
|
||||
|
|
@ -60,6 +60,11 @@ PeakMeter::~PeakMeter ()
|
|||
_iec2meter.pop_back();
|
||||
_vumeter.pop_back();
|
||||
}
|
||||
while (_peak_power.size() > 0) {
|
||||
_peak_buffer.pop_back();
|
||||
_peak_power.pop_back();
|
||||
_max_peak_signal.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -76,6 +81,10 @@ PeakMeter::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_fr
|
|||
if (!_active && !_pending_active) {
|
||||
return;
|
||||
}
|
||||
const bool do_reset_max = _reset_max;
|
||||
const bool do_reset_dpm = _reset_dpm;
|
||||
_reset_max = false;
|
||||
_reset_dpm = false;
|
||||
|
||||
// cerr << "meter " << name() << " runs with " << bufs.available() << " inputs\n";
|
||||
|
||||
|
|
@ -84,6 +93,10 @@ PeakMeter::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_fr
|
|||
|
||||
uint32_t n = 0;
|
||||
|
||||
const float falloff_dB = Config->get_meter_falloff() * nframes / _session.nominal_frame_rate();
|
||||
const int zoh = _session.nominal_frame_rate() * .021;
|
||||
_bufcnt += nframes;
|
||||
|
||||
// Meter MIDI in to the first n_midi peaks
|
||||
for (uint32_t i = 0; i < n_midi; ++i, ++n) {
|
||||
float val = 0.0f;
|
||||
|
|
@ -103,16 +116,46 @@ PeakMeter::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_fr
|
|||
}
|
||||
}
|
||||
}
|
||||
_peak_signal[n] = max (val, _peak_signal[n]);
|
||||
if (_peak_power[n] < (1.0 / 512.0)) {
|
||||
_peak_power[n] = 0;
|
||||
} else {
|
||||
/* empirical algorithm WRT to audio falloff times */
|
||||
_peak_power[n] -= sqrtf (_peak_power[n]) * falloff_dB * 0.045f;
|
||||
}
|
||||
_peak_power[n] = max(_peak_power[n], val);
|
||||
_max_peak_signal[n] = 0;
|
||||
}
|
||||
|
||||
// Meter audio in to the rest of the peaks
|
||||
for (uint32_t i = 0; i < n_audio; ++i, ++n) {
|
||||
if (bufs.get_audio(i).silent()) {
|
||||
_peak_signal[n] = .0f;
|
||||
;
|
||||
} else {
|
||||
_peak_signal[n] = compute_peak (bufs.get_audio(i).data(), nframes, _peak_signal[n]);
|
||||
_peak_buffer[n] = compute_peak (bufs.get_audio(i).data(), nframes, _peak_buffer[n]);
|
||||
_max_peak_signal[n] = std::max(_peak_buffer[n], _max_peak_signal[n]); // todo sync reset
|
||||
}
|
||||
|
||||
if (do_reset_max) {
|
||||
_max_peak_signal[n] = 0;
|
||||
}
|
||||
|
||||
if (do_reset_dpm) {
|
||||
_peak_buffer[n] = 0;
|
||||
_peak_power[n] = -std::numeric_limits<float>::infinity();
|
||||
} else {
|
||||
// falloff
|
||||
if (_peak_power[n] > -318.8f) {
|
||||
_peak_power[n] -= falloff_dB;
|
||||
} else {
|
||||
_peak_power[n] = -std::numeric_limits<float>::infinity();
|
||||
}
|
||||
_peak_power[n] = max(_peak_power[n], accurate_coefficient_to_dB(_peak_buffer[n]));
|
||||
// integration buffer, retain peaks > 49Hz
|
||||
if (_bufcnt > zoh) {
|
||||
_peak_buffer[n] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (_meter_type & (MeterKrms | MeterK20 | MeterK14 | MeterK12)) {
|
||||
_kmeter[i]->process(bufs.get_audio(i).data(), nframes);
|
||||
}
|
||||
|
|
@ -128,8 +171,13 @@ PeakMeter::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_fr
|
|||
}
|
||||
|
||||
// Zero any excess peaks
|
||||
for (uint32_t i = n; i < _peak_signal.size(); ++i) {
|
||||
_peak_signal[i] = 0.0f;
|
||||
for (uint32_t i = n; i < _peak_power.size(); ++i) {
|
||||
_peak_power[i] = -std::numeric_limits<float>::infinity();
|
||||
_max_peak_signal[n] = 0;
|
||||
}
|
||||
|
||||
if (_bufcnt > zoh) {
|
||||
_bufcnt = 0;
|
||||
}
|
||||
|
||||
_active = _pending_active;
|
||||
|
|
@ -138,10 +186,16 @@ PeakMeter::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_fr
|
|||
void
|
||||
PeakMeter::reset ()
|
||||
{
|
||||
for (size_t i = 0; i < _peak_signal.size(); ++i) {
|
||||
_peak_signal[i] = 0.0f;
|
||||
if (_active || _pending_active) {
|
||||
_reset_dpm = true;
|
||||
} else {
|
||||
for (size_t i = 0; i < _peak_power.size(); ++i) {
|
||||
_peak_power[i] = -std::numeric_limits<float>::infinity();
|
||||
_peak_buffer[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// these are handled async just fine.
|
||||
for (size_t n = 0; n < _kmeter.size(); ++n) {
|
||||
_kmeter[n]->reset();
|
||||
_iec1meter[n]->reset();
|
||||
|
|
@ -153,19 +207,13 @@ PeakMeter::reset ()
|
|||
void
|
||||
PeakMeter::reset_max ()
|
||||
{
|
||||
for (size_t i = 0; i < _max_peak_power.size(); ++i) {
|
||||
_max_peak_power[i] = -std::numeric_limits<float>::infinity();
|
||||
_max_peak_signal[i] = 0;
|
||||
if (_active || _pending_active) {
|
||||
_reset_max = true;
|
||||
return;
|
||||
}
|
||||
|
||||
const size_t n_midi = min (_peak_signal.size(), (size_t) current_meters.n_midi());
|
||||
|
||||
for (size_t n = 0; n < _peak_signal.size(); ++n) {
|
||||
if (n < n_midi) {
|
||||
_visible_peak_power[n] = 0;
|
||||
} else {
|
||||
_visible_peak_power[n] = -std::numeric_limits<float>::infinity();
|
||||
}
|
||||
for (size_t i = 0; i < _max_peak_signal.size(); ++i) {
|
||||
_max_peak_signal[i] = 0;
|
||||
_peak_buffer[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -185,7 +233,7 @@ PeakMeter::configure_io (ChanCount in, ChanCount out)
|
|||
|
||||
current_meters = in;
|
||||
|
||||
reset_max_channels (in);
|
||||
set_max_channels (in);
|
||||
|
||||
return Processor::configure_io (in, out);
|
||||
}
|
||||
|
|
@ -193,22 +241,9 @@ PeakMeter::configure_io (ChanCount in, ChanCount out)
|
|||
void
|
||||
PeakMeter::reflect_inputs (const ChanCount& in)
|
||||
{
|
||||
for (uint32_t i = in.n_total(); i < current_meters.n_total(); ++i) {
|
||||
if (i < _peak_signal.size()) {
|
||||
_peak_signal[i] = 0.0f;
|
||||
}
|
||||
}
|
||||
for (uint32_t i = in.n_audio(); i < current_meters.n_audio(); ++i) {
|
||||
if (i >= _kmeter.size()) continue;
|
||||
_kmeter[i]->reset();
|
||||
_iec1meter[i]->reset();
|
||||
_iec2meter[i]->reset();
|
||||
_vumeter[i]->reset();
|
||||
}
|
||||
|
||||
reset();
|
||||
current_meters = in;
|
||||
reset_max();
|
||||
|
||||
// ConfigurationChanged() postponed
|
||||
}
|
||||
|
||||
|
|
@ -218,29 +253,26 @@ PeakMeter::emit_configuration_changed () {
|
|||
}
|
||||
|
||||
void
|
||||
PeakMeter::reset_max_channels (const ChanCount& chn)
|
||||
PeakMeter::set_max_channels (const ChanCount& chn)
|
||||
{
|
||||
uint32_t const limit = chn.n_total();
|
||||
const size_t n_audio = chn.n_audio();
|
||||
|
||||
while (_peak_signal.size() > limit) {
|
||||
_peak_signal.pop_back();
|
||||
_visible_peak_power.pop_back();
|
||||
while (_peak_power.size() > limit) {
|
||||
_peak_buffer.pop_back();
|
||||
_peak_power.pop_back();
|
||||
_max_peak_signal.pop_back();
|
||||
_max_peak_power.pop_back();
|
||||
}
|
||||
|
||||
while (_peak_signal.size() < limit) {
|
||||
_peak_signal.push_back(0);
|
||||
_visible_peak_power.push_back(minus_infinity());
|
||||
while (_peak_power.size() < limit) {
|
||||
_peak_buffer.push_back(0);
|
||||
_peak_power.push_back(-std::numeric_limits<float>::infinity());
|
||||
_max_peak_signal.push_back(0);
|
||||
_max_peak_power.push_back(minus_infinity());
|
||||
}
|
||||
|
||||
assert(_peak_signal.size() == limit);
|
||||
assert(_visible_peak_power.size() == limit);
|
||||
assert(_peak_buffer.size() == limit);
|
||||
assert(_peak_power.size() == limit);
|
||||
assert(_max_peak_signal.size() == limit);
|
||||
assert(_max_peak_power.size() == limit);
|
||||
|
||||
/* alloc/free other audio-only meter types. */
|
||||
while (_kmeter.size() > n_audio) {
|
||||
|
|
@ -273,80 +305,6 @@ PeakMeter::reset_max_channels (const ChanCount& chn)
|
|||
* of meter size during this call.
|
||||
*/
|
||||
|
||||
void
|
||||
PeakMeter::meter ()
|
||||
{
|
||||
if (!_active) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO block this thread while PeakMeter::reset_max_channels() is
|
||||
// reallocating channels.
|
||||
// (may happen with Session > New: old session not yet closed,
|
||||
// meter-thread still active while new one is initializing and
|
||||
// maybe on other occasions, too)
|
||||
if ( (_visible_peak_power.size() != _peak_signal.size())
|
||||
|| (_max_peak_power.size() != _peak_signal.size())
|
||||
|| (_max_peak_signal.size() != _peak_signal.size())
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const size_t limit = min (_peak_signal.size(), (size_t) current_meters.n_total ());
|
||||
const size_t n_midi = min (_peak_signal.size(), (size_t) current_meters.n_midi());
|
||||
|
||||
/* 0.01f ^= 100 Hz update rate */
|
||||
const float midi_meter_falloff = Config->get_meter_falloff() * 0.01f;
|
||||
/* kmeters: 24dB / 2 sec */
|
||||
const float audio_meter_falloff = (_meter_type & (MeterK20 | MeterK14 | MeterK12)) ? 0.12f : midi_meter_falloff;
|
||||
|
||||
for (size_t n = 0; n < limit; ++n) {
|
||||
|
||||
/* grab peak since last read */
|
||||
|
||||
float new_peak = _peak_signal[n]; /* XXX we should use atomic exchange from here ... */
|
||||
_peak_signal[n] = 0; /* ... to here */
|
||||
|
||||
if (n < n_midi) {
|
||||
_max_peak_power[n] = -std::numeric_limits<float>::infinity(); // std::max (new_peak, _max_peak_power[n]); // XXX
|
||||
_max_peak_signal[n] = 0;
|
||||
if (midi_meter_falloff == 0.0f || new_peak > _visible_peak_power[n]) {
|
||||
;
|
||||
} else {
|
||||
/* empirical algorithm WRT to audio falloff times */
|
||||
new_peak = _visible_peak_power[n] - sqrt(_visible_peak_power[n] * midi_meter_falloff * 0.0002f);
|
||||
if (new_peak < (1.0 / 512.0)) new_peak = 0;
|
||||
}
|
||||
_visible_peak_power[n] = new_peak;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* AUDIO */
|
||||
|
||||
/* compute new visible value using falloff */
|
||||
|
||||
_max_peak_signal[n] = std::max(new_peak, _max_peak_signal[n]);
|
||||
|
||||
if (new_peak > 0.0) {
|
||||
new_peak = accurate_coefficient_to_dB (new_peak);
|
||||
} else {
|
||||
new_peak = minus_infinity();
|
||||
}
|
||||
|
||||
/* update max peak */
|
||||
|
||||
_max_peak_power[n] = std::max (new_peak, _max_peak_power[n]);
|
||||
|
||||
if (audio_meter_falloff == 0.0f || new_peak > _visible_peak_power[n]) {
|
||||
_visible_peak_power[n] = new_peak;
|
||||
} else {
|
||||
// do falloff
|
||||
new_peak = _visible_peak_power[n] - (audio_meter_falloff);
|
||||
_visible_peak_power[n] = std::max (new_peak, -std::numeric_limits<float>::infinity());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define CHECKSIZE(MTR) (n < MTR.size() + n_midi && n >= n_midi)
|
||||
|
||||
float
|
||||
|
|
@ -391,16 +349,17 @@ PeakMeter::meter_level(uint32_t n, MeterType type) {
|
|||
break;
|
||||
case MeterPeak:
|
||||
case MeterPeak0dB:
|
||||
return peak_power(n);
|
||||
case MeterMaxSignal:
|
||||
if (n < _max_peak_signal.size()) {
|
||||
return _max_peak_signal[n];
|
||||
if (n < _peak_power.size()) {
|
||||
return _peak_power[n];
|
||||
}
|
||||
break;
|
||||
case MeterMaxSignal:
|
||||
assert(0);
|
||||
break;
|
||||
default:
|
||||
case MeterMaxPeak:
|
||||
if (n < _max_peak_power.size()) {
|
||||
return _max_peak_power[n];
|
||||
if (n < _max_peak_signal.size()) {
|
||||
return accurate_coefficient_to_dB(_max_peak_signal[n]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -206,8 +206,6 @@ Route::init ()
|
|||
|
||||
/* now that we have _meter, its safe to connect to this */
|
||||
|
||||
Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
|
||||
|
||||
{
|
||||
Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
|
||||
configure_processors (0);
|
||||
|
|
@ -1915,7 +1913,7 @@ Route::configure_processors_unlocked (ProcessorStreams* err)
|
|||
|
||||
|
||||
if (_meter) {
|
||||
_meter->reset_max_channels (processor_max_streams);
|
||||
_meter->set_max_channels (processor_max_streams);
|
||||
}
|
||||
|
||||
/* make sure we have sufficient scratch buffers to cope with the new processor
|
||||
|
|
@ -4021,28 +4019,6 @@ Route::set_active (bool yn, void* src)
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
Route::meter ()
|
||||
{
|
||||
Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
|
||||
|
||||
assert (_meter);
|
||||
|
||||
_meter->meter ();
|
||||
|
||||
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
|
||||
|
||||
boost::shared_ptr<Send> s;
|
||||
boost::shared_ptr<Return> r;
|
||||
|
||||
if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
|
||||
s->meter()->meter();
|
||||
} else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
|
||||
r->meter()->meter ();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
boost::shared_ptr<Pannable>
|
||||
Route::pannable() const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -281,7 +281,7 @@ ControlProtocol::route_get_peak_input_power (uint32_t table_index, uint32_t whic
|
|||
return 0.0f;
|
||||
}
|
||||
|
||||
return r->peak_meter().peak_power (which_input);
|
||||
return r->peak_meter().meter_level (which_input, MeterPeak);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -719,7 +719,7 @@ void
|
|||
Strip::update_meter ()
|
||||
{
|
||||
if (_meter && _transport_is_rolling && _metering_active) {
|
||||
float dB = const_cast<PeakMeter&> (_route->peak_meter()).peak_power (0);
|
||||
float dB = const_cast<PeakMeter&> (_route->peak_meter()).meter_level (0, MeterPeak);
|
||||
_meter->send_update (*_surface, dB);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue