Kwave::LevelMeter Class Reference

#include <LevelMeter.h>

Inheritance diagram for Kwave::LevelMeter:

Collaboration diagram for Kwave::LevelMeter:

Public Slots
virtual void	setTracks (unsigned int tracks)
virtual void	setSampleRate (double rate)
virtual void	updateTrack (unsigned int track, const Kwave::SampleArray &buffer)
virtual void	reset ()
virtual void	drawContents ()

Public Member Functions
	LevelMeter (QWidget *parent)
virtual	~LevelMeter () Q_DECL_OVERRIDE
virtual void	paintEvent (QPaintEvent *) Q_DECL_OVERRIDE
virtual void	resizeEvent (QResizeEvent *) Q_DECL_OVERRIDE

Protected Slots
virtual void	timedUpdate ()

Protected Member Functions
virtual void	enqueue (unsigned int track, float fast, float peak, unsigned int queue_depth)
virtual bool	dequeue (unsigned int track, float &fast, float &peak)
void	drawScale (QPainter &p)

Private Attributes
int	m_tracks
float	m_sample_rate
QVector< float >	m_yf
QVector< float >	m_yp
QVector< QQueue< float > >	m_fast_queue
QVector< QQueue< float > >	m_peak_queue
QVector< float >	m_current_fast
QVector< float >	m_current_peak
QTimer *	m_timer
QColor	m_color_low
QColor	m_color_normal
QColor	m_color_high

Detailed Description

Definition at line 39 of file LevelMeter.h.

Constructor & Destructor Documentation

LevelMeter()

Kwave::LevelMeter::LevelMeter ( QWidget *  parent )

explicit

Constructor

Definition at line 54 of file LevelMeter.cpp.

References Kwave::connect(), m_timer, and timedUpdate().

    :QWidget(parent),
    m_tracks(0), m_sample_rate(0), m_yf(), m_yp(),
    m_fast_queue(), m_peak_queue(),
    m_current_fast(), m_current_peak(), m_timer(),
    m_color_low(Qt::green),
    m_color_normal(Qt::yellow),
    m_color_high(Qt::red)
{
    setAttribute(Qt::WA_NoBackground);
    m_timer = new QTimer(this);
    Q_ASSERT(m_timer);
    connect(m_timer, SIGNAL(timeout()),
            this, SLOT(timedUpdate()));
}

Here is the call graph for this function:

~LevelMeter()

Kwave::LevelMeter::~LevelMeter ( )

virtual

Destructor

Definition at line 71 of file LevelMeter.cpp.

References setTracks().

{
    setTracks(0);
}

Here is the call graph for this function:

Member Function Documentation

dequeue()

bool Kwave::LevelMeter::dequeue ( unsigned int  track, float &  fast, float &  peak  )

protectedvirtual

Dequeue a pair of fast and peek value of a track.

Parameters

track	index of the track [0...m_tracks-1]
fast	receives the value of the fast level bar [0.0 ... 1.0]
peak	receives value of the peak level [0.0 ... 1.0]

Returns

true if there was something to dequeue, false if the queue was empty.

Note

fast and peak will not be modified if the queue was empty

Definition at line 226 of file LevelMeter.cpp.

References m_fast_queue, m_peak_queue, m_tracks, and Kwave::toInt().

Referenced by timedUpdate().

{
    Q_ASSERT(m_peak_queue.size() == m_fast_queue.size());
    Q_ASSERT(m_fast_queue.size() >= m_tracks);
    Q_ASSERT(m_peak_queue.size() >= m_tracks);
    if ((Kwave::toInt(track) >= m_tracks) ||
        (m_fast_queue.size() < m_tracks) ||
        (m_peak_queue.size() < m_tracks)) return false;
    Q_ASSERT(m_peak_queue[track].size() == m_fast_queue[track].size());
    if (m_peak_queue[track].size() != m_fast_queue[track].size())
        return false;

    // check if the queues are empty
    if (m_fast_queue[track].isEmpty()) return false;
    if (m_peak_queue[track].isEmpty()) return false;

    // get the values from the front of the queue
    fast = m_fast_queue[track].dequeue();
    peak = m_peak_queue[track].dequeue();

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawContents

void Kwave::LevelMeter::drawContents ( )

virtualslot

Redraws the whole widget

Author

(original idea taken from) Rik Hemsley (rikkus) rik@k.nosp@m.de.o.nosp@m.rg Copyright 2002

Definition at line 344 of file LevelMeter.cpp.

References background, drawScale(), m_color_high, m_color_low, m_color_normal, m_current_fast, m_current_peak, m_tracks, rect(), and Kwave::toUint().

Referenced by paintEvent().

{
    QPainter p;
    int track;

    Q_ASSERT(width() > 0);
    Q_ASSERT(height() > 0);

    p.begin(this);

    // fill the background
    p.fillRect(rect(), palette().background().color());

    const unsigned int border = 4;
    const unsigned int cell = 3;
    const unsigned int w = width() - (border * 2) - (cell * 2);
    const unsigned int h = (height() - border) / (m_tracks ? m_tracks : 1);

    const unsigned int w_low  = Kwave::toUint(w * 0.7);  // -3 dB
    const unsigned int w_high = Kwave::toUint(w * 0.85); // -1.5dB

    for (track = 0; track < m_tracks; ++track) {
        // show a bar up to the "fast" value
        const unsigned int fast = Kwave::toUint(m_current_fast[track] * w);
        for (unsigned int i = 0; i < w; i += cell * 2) {
            QColor color;
            if (i >= w_high)
                color = m_color_high;
            else if (i >= w_low)
                color = m_color_normal;
            else
                color = m_color_low;

            p.fillRect(
                border + cell + i,
                border + (track * h),
                cell, h-border,
                (i > fast) ? color.dark() : color
            );
        }

        // draw the peak value
        unsigned int peak = Kwave::toUint(m_current_peak[track] * w);
        QColor peak_color;
        if (peak >= w_high)
            peak_color = m_color_high;
        else if (peak >= w_low)
            peak_color = m_color_normal;
        else
            peak_color = m_color_low;

        p.fillRect(
            border + cell + peak,
            border + (track * h),
            cell, h - border,
            peak_color.light()
        );
    }

    // draw the scale / dB numbers
    drawScale(p);

    p.end();
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawScale()

void Kwave::LevelMeter::drawScale ( QPainter &  p )

protected

Draw some scale into the meter, using 3dB steps

Parameters

p	an already opened QPainter

Definition at line 272 of file LevelMeter.cpp.

References background, rect(), and Kwave::toInt().

Referenced by drawContents().

{
    // draw the levels in 3dB steps, like -12dB -9dB  -6dB  -3dB and 0dB
    QFontMetrics fm = p.fontMetrics();
    QRect rect = fm.boundingRect(i18n("%1 dB", -999));

    const int border = 4;
    const int w  = width() - 2 * border;
    const int h  = height();
    const int tw = rect.width();
    const int th = rect.height();
    const int y  = ((height() - th) / 2);
    const int r  = 5;
    int db       = 0;
    int right    = width();
    const QColor textcolor = palette().buttonText().color();
    const QBrush brush(palette().background().color());

    Q_ASSERT(th);
    if (!th) return;

    p.setBrush(brush);
    while (right > tw + border) {
        // find the first position in dB which is not overlapping
        // the last output position
        QString txt;
        int x;
        do {
            txt = i18n("%1 dB", db);
            x = Kwave::toInt(static_cast<double>(w) *
                pow(10.0, static_cast<double>(db) / 20.0));
            db -= 3; // one step left == -3dB
        } while ((x > right) && (x >= tw));
        if (x < tw) break;

        // calculate the text position
        int text_width = fm.boundingRect(txt).width();
        x += border;
        x -= text_width + 3;

        // dim the text background area
        p.setOpacity(0.66);
        p.setPen(Qt::NoPen);
        p.drawRoundRect(x - r, y - r, text_width + 2 * r, th + 2 * r,
                        (200 * r) / th, (200 * r) / th);

        // draw the text, right/center aligned
        p.setOpacity(1.0);
        p.setPen(textcolor);
        p.drawText(x, 1, text_width, h, Qt::AlignCenter, txt);

        // new right border == one character left from last one
        right = x - th;
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

enqueue()

void Kwave::LevelMeter::enqueue ( unsigned int  track, float  fast, float  peak, unsigned int  queue_depth  )

protectedvirtual

Enqueue a pair of fast and peak value of a track for later timed update. If the queue already contains the maximum number of elements, the oldest ones will be removed.

Parameters

track	index of the track [0...m_tracks-1]
fast	value of the fast level bar [0.0 ... 1.0]
peak	value of the peak level [0.0 ... 1.0]
queue_depth	maximum number of elements to queue

Definition at line 192 of file LevelMeter.cpp.

References m_fast_queue, m_peak_queue, m_timer, m_tracks, Kwave::toInt(), and UPDATES_PER_SECOND.

Referenced by updateTrack().

{
    Q_ASSERT(Kwave::toInt(track) < m_tracks);
    Q_ASSERT(m_peak_queue.size() == m_fast_queue.size());
    Q_ASSERT(m_fast_queue.size() >= m_tracks);
    Q_ASSERT(m_peak_queue.size() >= m_tracks);
    if ((Kwave::toInt(track) >= m_tracks) ||
        (m_fast_queue.size() < Kwave::toInt(m_tracks)) ||
        (m_peak_queue.size() < m_tracks)) return;
    Q_ASSERT(m_peak_queue[track].size() == m_fast_queue[track].size());
    if (m_peak_queue[track].size() != m_fast_queue[track].size()) return;

    // remove old entries
    while (m_fast_queue[track].size() > Kwave::toInt(queue_depth)) {
//      qDebug("LevelMeter::enqueue(): purging old entry (%u/%u)",
//             m_fast_queue.size(), queue_depth);
        m_fast_queue[track].dequeue();
        m_peak_queue[track].dequeue();
    }

    // put into the queue
    m_fast_queue[track].enqueue(fast);
    m_peak_queue[track].enqueue(peak);

    // restart the timer if necessary
    if (m_timer && !m_timer->isActive()) {
        m_timer->setInterval(Kwave::toInt(1000 / UPDATES_PER_SECOND));
        m_timer->setSingleShot(false);
        m_timer->start();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

paintEvent()

void Kwave::LevelMeter::paintEvent ( QPaintEvent *  )

virtual

See also

QWidget::paintEvent

Definition at line 77 of file LevelMeter.cpp.

References drawContents().

{
    drawContents();
}

Here is the call graph for this function:

reset

void Kwave::LevelMeter::reset ( )

virtualslot

Resets all meters to zero

Definition at line 174 of file LevelMeter.cpp.

References m_current_fast, m_current_peak, m_fast_queue, m_peak_queue, m_timer, m_tracks, m_yf, and m_yp.

Referenced by setTracks().

{
    if (m_timer && m_timer->isActive()) m_timer->stop();

    m_yf.resize(m_tracks);
    m_yf.fill(0.0);
    m_fast_queue.resize(m_tracks);
    m_current_fast.resize(m_tracks);
    m_current_fast.fill(0.0);

    m_yp.resize(m_tracks);
    m_yp.fill(0.0);
    m_peak_queue.resize(m_tracks);
    m_current_peak.resize(m_tracks);
    m_current_peak.fill(0.0);
}

Here is the caller graph for this function:

resizeEvent()

void Kwave::LevelMeter::resizeEvent ( QResizeEvent *  )

virtual

See also

QWidget::resizeEvent

Definition at line 83 of file LevelMeter.cpp.

{
    repaint();
}

setSampleRate

void Kwave::LevelMeter::setSampleRate ( double  rate )

virtualslot

sets the sample rate for interpreting the samples used for updating the display.

Definition at line 97 of file LevelMeter.cpp.

References m_sample_rate.

{
    if (qFuzzyCompare(static_cast<float>(rate), m_sample_rate)) return;
    m_sample_rate = static_cast<float>(rate);
}

setTracks

void Kwave::LevelMeter::setTracks ( unsigned int  tracks )

virtualslot

sets the number of tracks that the display should use

Definition at line 89 of file LevelMeter.cpp.

References m_tracks, reset(), and Kwave::toInt().

Referenced by ~LevelMeter().

{
    if (Kwave::toInt(tracks) == m_tracks) return;
    m_tracks = tracks;
    reset(); // re-create all arrays etc.
}

Here is the call graph for this function:

Here is the caller graph for this function:

timedUpdate

void Kwave::LevelMeter::timedUpdate ( )

protectedvirtualslot

Called via m_timer to update the bar(s)

Definition at line 250 of file LevelMeter.cpp.

References dequeue(), m_current_fast, m_current_peak, and m_tracks.

Referenced by LevelMeter().

{
    float fast;
    float peak;
    bool need_update = false;

    for (int track=0; track < m_tracks; track++) {
        if (dequeue(track, fast, peak)) {
            // set the new "current" values
            m_current_fast[track] = fast;
            m_current_peak[track] = peak;

            // remember that we have to update the display
            need_update = true;
        }
    }

    // refresh the display if needed
    if (need_update) repaint();
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateTrack

void Kwave::LevelMeter::updateTrack ( unsigned int  track, const Kwave::SampleArray &  buffer  )

virtualslot

Updates a apecific track

Parameters

track	index of the track
buffer	array with samples

Definition at line 104 of file LevelMeter.cpp.

References enqueue(), F_FAST_DECAY, F_FAST_RISE, F_PEAK_DECAY, F_PEAK_RISE, m_sample_rate, m_tracks, m_yf, m_yp, sample2float(), Kwave::SampleArray::size(), Kwave::toInt(), Kwave::toUint(), and UPDATES_PER_SECOND.

{
    Q_ASSERT(Kwave::toInt(track) < m_tracks);
    if (Kwave::toInt(track) >= m_tracks) return;

    // calculate the number of samples per update (approx)
    const unsigned int samples = buffer.size();
    const unsigned int samples_per_update = Kwave::toUint(
        rintf(ceilf(m_sample_rate / UPDATES_PER_SECOND)));
    unsigned int next_fraction = samples_per_update;
    const unsigned int queue_depth = ((samples / samples_per_update) + 2);

    /* fast update: rise */
    float Fg = F_FAST_RISE / m_sample_rate;
    float n = 1.0f / tanf(float(M_PI) * Fg);
    const float a0_fr = 1.0f / (1.0f + n);
    const float b1_fr = (1.0f - n) / (1.0f + n);

    /* fast update: decay */
    Fg = F_FAST_DECAY / m_sample_rate;
    n = 1.0f / tanf(float(M_PI) * Fg);
    const float a0_fd = 1.0f / (1.0f + n);
    const float b1_fd = (1.0f - n) / (1.0f + n);

    /* peak value: rise */
    Fg = F_PEAK_RISE / m_sample_rate;
    n = 1.0f / tanf(float(M_PI) * Fg);
    const float a0_pr = 1.0f / (1.0f + n);
    const float b1_pr = (1.0f - n) / (1.0f + n);

    /* peak value: decay */
    Fg = F_PEAK_DECAY / m_sample_rate;
    n = 1.0f / tanf(float(M_PI) * Fg);
    const float a0_pd = 1.0f / (1.0f + n);
    const float b1_pd = (1.0f - n) / (1.0f + n);

    float yf = m_yf[track];
    float yp = m_yp[track];
    float last_x = yf;
    for (unsigned int t = 0; t < samples; ++t) {
        float x = fabsf(sample2float(buffer[t])); /* rectifier */

        /* fast value */
        if (x > yf) yf = (a0_fr * x) + (a0_fr * last_x) - (b1_fr * yf); // rise
        yf = (a0_fd * x) + (a0_fd * last_x) - (b1_fd * yf); // decay

        /* peak value */
        if (x > yp) yp = (a0_pr * x) + (a0_pr * last_x) - (b1_pr * yp); // rise
        yp = (a0_pd * x) + (a0_pd * last_x) - (b1_pd * yp); // decay

        // remember x[t-1]
        last_x = x;

        // enqueue new values if limit reached
        if ((t > next_fraction) || (t == samples-1)) {
            next_fraction += samples_per_update;

            // merge the last fractional part to the last normal part
            if ((next_fraction + samples_per_update) > samples)
               next_fraction = samples-1;

            enqueue(track, yf, yp, queue_depth);
        }
    }
    m_yf[track] = yf;
    m_yp[track] = yp;
}

Here is the call graph for this function:

Member Data Documentation

m_color_high

QColor Kwave::LevelMeter::m_color_high

private

color high levels, above -1.5dB

Definition at line 159 of file LevelMeter.h.

Referenced by drawContents().

m_color_low

QColor Kwave::LevelMeter::m_color_low

private

color for low levels, below -3dB

Definition at line 153 of file LevelMeter.h.

Referenced by drawContents().

m_color_normal

QColor Kwave::LevelMeter::m_color_normal

private

color for normal levels, -3dB...-1.5dB

Definition at line 156 of file LevelMeter.h.

Referenced by drawContents().

m_current_fast

QVector<float> Kwave::LevelMeter::m_current_fast

private

current fast value for each track

Definition at line 144 of file LevelMeter.h.

Referenced by drawContents(), reset(), and timedUpdate().

m_current_peak

QVector<float> Kwave::LevelMeter::m_current_peak

private

current peak value for each track

Definition at line 147 of file LevelMeter.h.

Referenced by drawContents(), reset(), and timedUpdate().

m_fast_queue

QVector< QQueue<float> > Kwave::LevelMeter::m_fast_queue

private

queues with fast update values for each track

Definition at line 138 of file LevelMeter.h.

Referenced by dequeue(), enqueue(), and reset().

m_peak_queue

QVector< QQueue<float> > Kwave::LevelMeter::m_peak_queue

private

queues with peak values for each track

Definition at line 141 of file LevelMeter.h.

Referenced by dequeue(), enqueue(), and reset().

m_sample_rate

float Kwave::LevelMeter::m_sample_rate

private

sample rate used for interpreting the received buffers

Definition at line 129 of file LevelMeter.h.

Referenced by setSampleRate(), and updateTrack().

m_timer

QTimer* Kwave::LevelMeter::m_timer

private

timer for display updates

Definition at line 150 of file LevelMeter.h.

Referenced by enqueue(), LevelMeter(), and reset().

m_tracks

int Kwave::LevelMeter::m_tracks

private

number of tracks

Definition at line 126 of file LevelMeter.h.

Referenced by dequeue(), drawContents(), enqueue(), reset(), setTracks(), timedUpdate(), and updateTrack().

m_yf

QVector<float> Kwave::LevelMeter::m_yf

private

last output value of the filter for fast updates

Definition at line 132 of file LevelMeter.h.

Referenced by reset(), and updateTrack().

m_yp

QVector<float> Kwave::LevelMeter::m_yp

private

last output value of the filter for peak updates

Definition at line 135 of file LevelMeter.h.

Referenced by reset(), and updateTrack().

---

The documentation for this class was generated from the following files:

• plugins/record/LevelMeter.h
• plugins/record/LevelMeter.cpp