Kwave::TrackPixmap Class Reference

#include <TrackPixmap.h>

Inheritance diagram for Kwave::TrackPixmap:

Collaboration diagram for Kwave::TrackPixmap:

Public Slots
void	setOffset (sample_index_t offset)
void	setZoom (double zoom)

Signals
void	sigModified ()

Public Member Functions
	TrackPixmap (Kwave::Track &track)
virtual	~TrackPixmap ()
virtual void	resize (int width, int height)
virtual int	width () const
virtual int	height () const
virtual const QPixmap &	pixmap () const
virtual void	repaint ()
virtual void	setVerticalZoom (double zoom)
virtual bool	isModified ()
virtual void	setModified ()

Private Slots
void	slotSamplesInserted (Kwave::Track *src, sample_index_t offset, sample_index_t length)
void	slotSamplesDeleted (Kwave::Track *src, sample_index_t offset, sample_index_t length)
void	slotSamplesModified (Kwave::Track *src, sample_index_t offset, sample_index_t length)
void	selectionChanged ()

Private Member Functions
void	resizeBuffer ()
void	invalidateBuffer ()
bool	validateBuffer ()
void	drawOverview (QPainter &p, int middle, int height, int first, int last)
void	calculateInterpolation ()
void	drawInterpolatedSignal (QPainter &p, int width, int middle, int height)
void	drawPolyLineSignal (QPainter &p, int width, int middle, int height)
sample_index_t	pixels2samples (int pixels)
int	samples2pixels (sample_index_t samples)
void	convertOverlap (sample_index_t &offset, sample_index_t &length)

Private Attributes
QPixmap	m_pixmap
Kwave::Track &	m_track
sample_index_t	m_offset
double	m_zoom
double	m_vertical_zoom
bool	m_minmax_mode
Kwave::SampleArray	m_sample_buffer
Kwave::SampleArray	m_min_buffer
Kwave::SampleArray	m_max_buffer
bool	m_modified
QBitArray	m_valid
QMutex	m_lock_buffer
int	m_interpolation_order
QVector< double >	m_interpolation_alpha
Kwave::Colors::ColorSet	m_colors

Detailed Description

Definition at line 67 of file TrackPixmap.h.

Constructor & Destructor Documentation

TrackPixmap()

Kwave::TrackPixmap::TrackPixmap ( Kwave::Track &  track )

explicit

Default constructor

Definition at line 50 of file TrackPixmap.cpp.

References Kwave::connect(), selectionChanged(), slotSamplesDeleted(), slotSamplesInserted(), and slotSamplesModified().

    :QObject(), m_pixmap(), m_track(track), m_offset(0), m_zoom(0.0),
    m_vertical_zoom(1.0), m_minmax_mode(false),
    m_sample_buffer(), m_min_buffer(), m_max_buffer(),
    m_modified(false), m_valid(0), m_lock_buffer(),
    m_interpolation_order(0), m_interpolation_alpha(),
    m_colors(Kwave::Colors::Normal)
{
    // connect all the notification signals of the track
    connect(&track,
        SIGNAL(sigSamplesInserted(Kwave::Track *, sample_index_t,
        sample_index_t)), this,
        SLOT(slotSamplesInserted(Kwave::Track *,
        sample_index_t, sample_index_t)));
    connect(&track, SIGNAL(sigSamplesDeleted(Kwave::Track *, sample_index_t,
        sample_index_t)), this, SLOT(slotSamplesDeleted(Kwave::Track *,
        sample_index_t, sample_index_t)));
    connect(&track, SIGNAL(sigSamplesModified(Kwave::Track *, sample_index_t,
        sample_index_t)), this, SLOT(slotSamplesModified(Kwave::Track *,
        sample_index_t, sample_index_t)));
    connect(&track, SIGNAL(sigSelectionChanged(bool)),
            this, SLOT(selectionChanged()));
}

Here is the call graph for this function:

~TrackPixmap()

Kwave::TrackPixmap::~TrackPixmap ( )

virtual

Destructor

Definition at line 75 of file TrackPixmap.cpp.

References m_interpolation_alpha, and m_lock_buffer.

{
    QMutexLocker lock(&m_lock_buffer);
    m_interpolation_alpha.clear();
}

Member Function Documentation

calculateInterpolation()

void Kwave::TrackPixmap::calculateInterpolation ( )

private

Calculates the parameters for interpolation of the graphical display when zoomed in. Allocates (new) buffer for the filter coefficients of the low pass filter used for interpolation.

See also

m_interpolation_alpha

Definition at line 491 of file TrackPixmap.cpp.

References INTERPOLATION_PRECISION, m_interpolation_alpha, m_interpolation_order, m_zoom, and samples2pixels().

Referenced by drawInterpolatedSignal().

{
    double f;
    double Fg;
    int k;
    int N;

//    qDebug("TrackPixmap::calculateInterpolation()");

    // remove all previous coefficents and signal buffer
    m_interpolation_alpha.clear();

    Q_ASSERT(!qFuzzyIsNull(m_zoom));
    if (qFuzzyIsNull(m_zoom)) return;

    // offset: index of first visible sample (left) [0...length-1]
    // m_zoom: number of samples / pixel

    // approximate the 3dB frequency of the low pass as
    // Fg = f_g / f_a
    // f_a: current "sample rate" of display (pixels) = 1.0
    // f_g: signal rate = (m_zoom/2)
    Fg = m_zoom / 2;

    // N: order of the filter, at least 2 * (1 / m_zoom)
    N = samples2pixels(INTERPOLATION_PRECISION);
    N |= 0x01;    // make N an odd number !

    // allocate a buffer for the coefficients
    m_interpolation_alpha = QVector<double>(N + 1);
    m_interpolation_order = N;

    Q_ASSERT(m_interpolation_alpha.count() == (N + 1));
    if (m_interpolation_alpha.count() != (N + 1)) return;

    // calculate the raw coefficients and
    // apply a Hamming window
    //
    //                    sin( (2k-N) * Pi * Fg )                       2kPi
    // alpha_k = 2 * Fg * ----------------------- * [ 0,54 - 0,46 * cos ---- ]
    //                      (2k - N) * Pi * Fg                            N
    //
    f = 0.0;    // (store the sum of all coefficients in "f")
    for (k = 0; k <= N; ++k) {
        m_interpolation_alpha[k] =
            sin((2 * k - N) * M_PI * Fg) / ((2 * k - N) * M_PI * Fg);
        m_interpolation_alpha[k] *= (0.54 - 0.46 * cos(2 * k * M_PI / N));
        f += m_interpolation_alpha[k];
    }
    // norm the coefficients to 1.0 / m_zoom
    f *= m_zoom;
    for (k = 0; k <= N; ++k)
        m_interpolation_alpha[k] /= f;

}

Here is the call graph for this function:

Here is the caller graph for this function:

convertOverlap()

void Kwave::TrackPixmap::convertOverlap ( sample_index_t &  offset, sample_index_t &  length  )

private

Converts the offset and length of an overlapping region into buffer indices, depending on the current mode. If the given region does not overlap at all, the length of the area will be set to zero. The length will be truncated to the end of the current buffer(s).

Note

If the resulting or given length is zero, the offset value is not necessarily valid and should be ignored!

Parameters

offset	reference to the source sample index, will be converted into buffer index
length	reference to the length in samples, will be converted to the number of buffer indices

Definition at line 790 of file TrackPixmap.cpp.

References m_minmax_mode, m_offset, m_valid, and m_zoom.

Referenced by slotSamplesDeleted(), slotSamplesInserted(), and slotSamplesModified().

{
    if (m_zoom <= 0.0) length = 0;
    if (!length) return;
    if ((offset + length) <= m_offset) {
        length = 0;
        return; // not yet in view
    }

    unsigned int buflen = m_valid.size();
    if (!buflen) {
        offset = 0;
        length = 0;
        return;
    }

    // calculate the length
    if (m_minmax_mode) {
        // attention: round up the length int this mode!
        if (offset >= m_offset + static_cast<sample_index_t>(
            ceil(buflen * m_zoom)))
        {
            length = 0; // out of view
            return;
        } else {
            length = static_cast<sample_index_t>(ceil(length / m_zoom));
        }
    } else {
        if (offset >= m_offset + buflen) {
            length = 0; // out of view
            return;
        }
    }

    // convert the offset
    offset = (offset > m_offset) ? offset - m_offset : 0;
    if (m_minmax_mode) {
        // attention: round down in this mode!
        sample_index_t ofs = static_cast<sample_index_t>(floor(offset / m_zoom));

        // if offset was rounded down, increment length
        if (ofs != static_cast<sample_index_t>(ceil(offset / m_zoom)))
            length++;
        offset = ofs;
    }

    // limit the offset (maybe something happened when rounding)
    if (offset >= buflen) offset = buflen - 1;

    // limit the length to the end of the buffer
    if (offset + length > buflen) length = buflen - offset;

    Q_ASSERT(length);
}

Here is the caller graph for this function:

drawInterpolatedSignal()

void Kwave::TrackPixmap::drawInterpolatedSignal ( QPainter &  p, int  width, int  middle, int  height  )

private

Draws the signal and interpolates the pixels between the samples. The interpolation is done by using a simple FIR lowpass filter.

Parameters

p	reference to a QPainter
width	the width of the pixmap in pixels
middle	the y position of the zero line in the drawing area [pixels]
height	the height of the drawing are [pixels]

See also

calculateInterpolation()

Definition at line 548 of file TrackPixmap.cpp.

References calculateInterpolation(), height(), Kwave::Colors::ColorSet::interpolated, INTERPOLATION_PRECISION, m_colors, m_interpolation_alpha, m_interpolation_order, m_sample_buffer, m_valid, m_vertical_zoom, m_zoom, Kwave::Colors::ColorSet::sample, SAMPLE_MAX, samples2pixels(), Kwave::toInt(), and width().

Referenced by repaint().

{
    float *sig;
    float *sig_buffer;
    float scale_y;
    int i;
    int k;
    int N;
    int sample;
    int x;
    int buflen = m_valid.size();
    const Kwave::SampleArray &sample_buffer = m_sample_buffer;

//     qDebug("TrackPixmap::drawInterpolatedSignal()");

    Q_ASSERT(m_zoom > 0);
    if (m_zoom <= 0) return;

    // scale_y: pixels per unit
    scale_y = static_cast<float>(m_vertical_zoom * height) /
              static_cast<float>((SAMPLE_MAX + 1) << 1);

    // N: order of the filter, at least 2 * (1/m_zoom)
    N = samples2pixels(INTERPOLATION_PRECISION);
    N |= 0x01;    // make N an odd number !

    // re-calculate the interpolation's filter and buffers
    // if the current order has changed
    if (m_interpolation_order != N) {
        calculateInterpolation();
        N = m_interpolation_order;
    }

    Q_ASSERT(m_interpolation_alpha.count() == (N + 1));
    if (m_interpolation_alpha.count() != (N + 1)) return;

    // buffer for intermediate resampled data
    sig_buffer = new(std::nothrow) float[width + N + 2];
    Q_ASSERT(sig_buffer);
    if (!sig_buffer) return;

    // fill the sample buffer with zeroes
    for (i = 0; i < width + N + 2; ++i)
        sig_buffer[i] = 0.0;

    // resample
    x = -1 * samples2pixels(2);
    sample = -2;    // start some samples left of the window
    sig = sig_buffer + (N / 2);
    while (x <= width + N / 2) {
        if ((x >= -N / 2) && (sample > 0) && (sample < buflen)) {
            sig[x] = static_cast<float>(sample_buffer[sample] * scale_y);
        }
        sample++;
        x = Q_LIKELY(sample >= 0) ?
            samples2pixels(sample) :
            (-1 * samples2pixels(-1 * sample));
    }

    // array with sample points
    QPolygon points;

    // pass the signal data through the filter
    for (i = 0; i < width; ++i) {
        sig = sig_buffer + (i + N);
        float y = 0.0;
        for (k = 0; k <= N; ++k, --sig)
            y += (*sig) * static_cast<float>(m_interpolation_alpha[k]);
        points.append(QPoint(i, middle - Kwave::toInt(y)));
    }

    // display the filter's interpolated output
    p.setPen(m_colors.interpolated);
    p.drawPolyline(points);

    // display the original samples
    sample = 0;
    x = samples2pixels(sample);
    sig = sig_buffer + (N / 2);
    p.setPen(m_colors.sample);
    i = 0;
    points.clear();
    while (x < width) {
        if ((x >= 0) && (x < width)) {
            // mark original samples
            points.append(QPoint(x, middle - Kwave::toInt(sig[x])));
        }
        sample++;
        x = samples2pixels(sample);
    }
    p.drawPoints(points);

    delete[] sig_buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawOverview()

void Kwave::TrackPixmap::drawOverview ( QPainter &  p, int  middle, int  height, int  first, int  last  )

private

Draws the signal as an overview with multiple samples per pixel.

Parameters

p	reference to a QPainter
middle	the y position of the zero line [pixels]
height	the height of the pixmap [pixels]
first	the offset of the first pixel
last	the offset of the last pixel

Definition at line 457 of file TrackPixmap.cpp.

References height(), m_colors, m_max_buffer, m_min_buffer, m_minmax_mode, m_valid, m_vertical_zoom, Kwave::Colors::ColorSet::sample, SAMPLE_BITS, Kwave::SampleArray::size(), Kwave::toInt(), and width().

Referenced by repaint().

{
    const Kwave::SampleArray &min_buffer = m_min_buffer;
    const Kwave::SampleArray &max_buffer = m_max_buffer;

    Q_ASSERT(m_minmax_mode);
    Q_ASSERT(width() <= Kwave::toInt(min_buffer.size()));
    Q_ASSERT(width() <= Kwave::toInt(max_buffer.size()));

    // scale_y: pixels per unit
    double scale_y = (m_vertical_zoom * height) / (1 << SAMPLE_BITS);

    p.setPen(m_colors.sample);
    int last_min = Kwave::toInt(min_buffer[first] * scale_y);
    int last_max = Kwave::toInt(max_buffer[first] * scale_y);
    for (int i = first; i <= last; i++) {
        Q_ASSERT(m_valid[i]);
        int max = Kwave::toInt(max_buffer[i] * scale_y);
        int min = Kwave::toInt(min_buffer[i] * scale_y);

        // make sure there is a connection between this
        // section and the one before, avoid gaps
        if (min > last_max + 1) min = last_max + 1;
        if (max + 1 < last_min) max = last_min - 1;

        p.drawLine(i, middle - max, i, middle - min);

        last_min = min;
        last_max = max;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawPolyLineSignal()

void Kwave::TrackPixmap::drawPolyLineSignal ( QPainter &  p, int  width, int  middle, int  height  )

private

Draws the signal and connects the pixels between the samples by using a simple poly-line. This gets used if the current zoom factor is not suitable for either an overview nor an interpolated signal display.

Parameters

p	reference to a QPainter
width	the width of the pixmap in pixels
middle	the y position of the zero line in the drawing area [pixels]
height	the height of the drawing are [pixels]

Definition at line 645 of file TrackPixmap.cpp.

References height(), m_sample_buffer, m_vertical_zoom, m_zoom, SAMPLE_MAX, samples2pixels(), Kwave::SampleArray::size(), and Kwave::toInt().

Referenced by repaint().

{
    const Kwave::SampleArray &sample_buffer = m_sample_buffer;
    double scale_y;
    unsigned int sample;
    unsigned int buflen = sample_buffer.size();

    // scale_y: pixels per unit
    scale_y = (m_vertical_zoom * static_cast<double>(height)) /
        static_cast<double>((SAMPLE_MAX + 1) << 1);

    // array with sample points
    QPolygon points;

    // display the original samples
    sample = 0;
    int x = 0;
    int y = 0;
    while (x < width) {
        // mark original samples
        sample_t value = (sample < buflen) ? sample_buffer[sample] : 0;
        y = Kwave::toInt(value * scale_y);
        points.append(QPoint(x, middle - y));

        sample++;
        x = samples2pixels(sample);
    }

    // interpolate the rest of the display if necessary
    if (samples2pixels(sample - 1) <= width) {
        int x1;
        int x2;
        float y1;
        float y2;

        x1 = samples2pixels(sample - 1);
        x2 = samples2pixels(sample);

        y1 = ((sample) && (sample <= buflen)) ?
            Kwave::toInt(scale_y * sample_buffer[sample - 1]) : 0.0;
        y2 = (sample < buflen) ?
            Kwave::toInt(scale_y * sample_buffer[sample    ]) : 0.0;

        x = width - 1;
        y = Kwave::toInt(static_cast<float>(x - x1) *
            static_cast<float>(y2 - y1) / static_cast<float>(x2 - x1));

        points.append(QPoint(x, middle - y));
    }

    if (m_zoom >= 1.0) {
        // show only poly-line (bright)
        p.setPen(Qt::white);
        p.drawPolyline(points);
    } else {
        // show the poly-line (dark)
        p.setPen(Qt::darkGray);
        p.drawPolyline(points);

        // show the original points (bright)
        p.setPen(Qt::white);
        p.drawPoints(points);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

height()

virtual int Kwave::TrackPixmap::height ( ) const

inlinevirtual

Get the height of the pixmap

Returns

the height of the pixmap in pixels

Definition at line 96 of file TrackPixmap.h.

Referenced by drawInterpolatedSignal(), drawOverview(), drawPolyLineSignal(), Kwave::TrackView::paintEvent(), and repaint().

{ return m_pixmap.height(); }

Here is the caller graph for this function:

invalidateBuffer()

void Kwave::TrackPixmap::invalidateBuffer ( )

private

Sets the current buffer to "invalid" state. Note: this does not include any resize!

Definition at line 267 of file TrackPixmap.cpp.

References m_modified, and m_valid.

Referenced by setOffset(), setZoom(), and validateBuffer().

{
    m_valid.fill(false);
    m_modified = true;
}

Here is the caller graph for this function:

isModified()

bool Kwave::TrackPixmap::isModified ( )

virtual

Returns "true" if the buffer has changed and the pixmap has to be re-painted.

Definition at line 443 of file TrackPixmap.cpp.

References m_lock_buffer, and m_modified.

Referenced by Kwave::TrackView::paintEvent(), and Kwave::TrackView::setZoomAndOffset().

{
    QMutexLocker lock(&m_lock_buffer);
    return m_modified;
}

Here is the caller graph for this function:

pixels2samples()

sample_index_t Kwave::TrackPixmap::pixels2samples ( int  pixels )

inlineprivate

Converts a pixel offset into a sample offset.

Definition at line 262 of file TrackPixmap.h.

Referenced by resizeBuffer(), and setOffset().

                                                         {
            return static_cast<sample_index_t>(rint(
                static_cast<double>(pixels) * m_zoom));
        }

Here is the caller graph for this function:

pixmap()

virtual const QPixmap& Kwave::TrackPixmap::pixmap ( ) const

inlinevirtual

Get the internal QPixmap object

Returns

reference to m_pixmap

Definition at line 102 of file TrackPixmap.h.

Referenced by Kwave::TrackView::paintEvent().

{ return m_pixmap; }

Here is the caller graph for this function:

repaint()

void Kwave::TrackPixmap::repaint ( )

virtual

Repaints the current pixmap. After the repaint the pixmap is no longer in status "modified". If it was not modified before, this is a no-op.

Definition at line 382 of file TrackPixmap.cpp.

References Kwave::Colors::ColorSet::background, Kwave::Colors::Disabled, drawInterpolatedSignal(), drawOverview(), drawPolyLineSignal(), height(), INTERPOLATION_ZOOM, Kwave::Track::length(), m_colors, m_lock_buffer, m_minmax_mode, m_modified, m_offset, m_pixmap, m_track, m_zoom, Kwave::Colors::Normal, samples2pixels(), Kwave::Track::selected(), validateBuffer(), width(), Kwave::Colors::ColorSet::zero, and Kwave::Colors::ColorSet::zero_unused.

Referenced by Kwave::TrackView::paintEvent(), and Kwave::TrackView::refresh().

{
    QMutexLocker lock(&m_lock_buffer);

    int w = width();
    int h = height();

    if (!w || !h) return; // not valid yet

    if (m_track.selected()) {
        m_colors = Kwave::Colors::Normal;
    } else {
        m_colors = Kwave::Colors::Disabled;
    }

    QPainter p(&m_pixmap);
    p.fillRect(0, 0, w, h, m_colors.background);

    if (m_zoom > 0) {
        // first make the buffer valid
        validateBuffer();

        // then draw the samples
        if (m_minmax_mode) {
            drawOverview(p, h >> 1, h, 0, w - 1);
        } else {
            if (m_zoom < INTERPOLATION_ZOOM) {
                drawInterpolatedSignal(p, w, h >> 1, h);
            } else {
                drawPolyLineSignal(p, w, h >> 1, h);
            }
        }

        // draw the zero-line
        int last = (m_track.length() > m_offset) ?
            samples2pixels(m_track.length() - 1 - m_offset) : 0;
        p.setPen(m_colors.zero);
        if (last >= w) {
            p.drawLine(0, h >> 1, w - 1, h >> 1);
        } else {
            p.drawLine(0, h >> 1, last, h >> 1);
            p.setPen(m_colors.zero_unused);
            p.drawLine(last, h >> 1, w, h >> 1);
        }
    }

    // now we are no longer "modified"
    m_modified = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resize()

void Kwave::TrackPixmap::resize ( int  width, int  height  )

virtual

Resize the pixmap.

Parameters

width	new width in pixels
height	new height in pixels

Definition at line 252 of file TrackPixmap.cpp.

References m_lock_buffer, m_modified, m_pixmap, and resizeBuffer().

Referenced by Kwave::TrackView::paintEvent().

{
    QMutexLocker lock(&m_lock_buffer);

    int old_width = m_pixmap.width();
    int old_height = m_pixmap.height();
    if ((old_width == width) && (old_height == height)) return; // no change

    m_pixmap = QPixmap(width, height);
    if (width != old_width) resizeBuffer();

    m_modified = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resizeBuffer()

void Kwave::TrackPixmap::resizeBuffer ( )

private

Resizes the current buffer and sets all new entries to invalid (if any).

Definition at line 192 of file TrackPixmap.cpp.

References m_max_buffer, m_min_buffer, m_minmax_mode, m_sample_buffer, m_valid, pixels2samples(), Kwave::SampleArray::resize(), Kwave::toInt(), and width().

Referenced by resize(), and setZoom().

{
    bool ok = true;
    int buflen;
    int oldlen = m_valid.size();
    int w      = width();
    Q_ASSERT(w >= 0);

    if (m_minmax_mode) {
        // one buffer index == one screen pixel
        buflen = w;
        ok &= m_min_buffer.resize(buflen);
        Q_ASSERT(ok);
        ok &= m_max_buffer.resize(buflen);
        Q_ASSERT(ok);
    } else {
        // one buffer index == one sample
        buflen = Kwave::toInt(pixels2samples(w));
        ok &= m_sample_buffer.resize(buflen);
        Q_ASSERT(ok);
    }
    m_valid.resize(buflen);
    while (oldlen < buflen) m_valid.clearBit(oldlen++);
}

Here is the call graph for this function:

Here is the caller graph for this function:

samples2pixels()

int Kwave::TrackPixmap::samples2pixels ( sample_index_t  samples )

inlineprivate

Converts a sample offset into a pixel offset.

Definition at line 270 of file TrackPixmap.h.

References Kwave::toInt().

Referenced by calculateInterpolation(), drawInterpolatedSignal(), drawPolyLineSignal(), repaint(), and setOffset().

                                                          {
            if (m_zoom <= 0) return 0;
            return Kwave::toInt(rint(static_cast<double>(samples) / m_zoom));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

selectionChanged

void Kwave::TrackPixmap::selectionChanged ( )

privateslot

Sets the state of the pixmap to "modified" whenever the selection of the track has changed

Definition at line 450 of file TrackPixmap.cpp.

References m_lock_buffer, and m_modified.

Referenced by TrackPixmap().

{
    QMutexLocker lock(&m_lock_buffer);
    m_modified = true;
}

Here is the caller graph for this function:

setModified()

virtual void Kwave::TrackPixmap::setModified ( )

inlinevirtual

Sets the internal "modified" flag

Definition at line 124 of file TrackPixmap.h.

{ m_modified = true; }

setOffset

void Kwave::TrackPixmap::setOffset ( sample_index_t  offset )

slot

Sets a new sample offset and moves the signal display left or right. Only the new areas that were moved in will be redrawn.

Parameters

offset

index of the first visible sample

Definition at line 82 of file TrackPixmap.cpp.

References invalidateBuffer(), m_lock_buffer, m_max_buffer, m_min_buffer, m_minmax_mode, m_modified, m_offset, m_sample_buffer, m_valid, m_zoom, pixels2samples(), samples2pixels(), Kwave::SampleArray::size(), Kwave::toInt(), and Kwave::toUint().

Referenced by Kwave::TrackView::setZoomAndOffset().

{
    QMutexLocker lock(&m_lock_buffer);
    if (offset == m_offset) return; // no change
    const unsigned int buflen = m_valid.size();

    if (m_minmax_mode) {
        // move content of min and max buffer
        // one buffer element = one screen pixel
        Q_ASSERT(buflen == m_min_buffer.size());
        Q_ASSERT(buflen == m_max_buffer.size());
        if ((buflen != m_min_buffer.size()) ||
            (buflen != m_max_buffer.size()))
        {
            qDebug("TrackPixmap::setOffset(): buflen = %u", buflen);
            qDebug("TrackPixmap::setOffset(): min_buffer : %u",
                   m_min_buffer.size());
            qDebug("TrackPixmap::setOffset(): max_buffer : %u",
                   m_max_buffer.size());
        }

        // check for misaligned offset changes
        if ((  offset % static_cast<sample_index_t>(ceil(m_zoom))) !=
            (m_offset % static_cast<sample_index_t>(ceil(m_zoom)))) {

#ifdef CURRENTLY_UNUSED
// this will become interesting later, with the offset/zoom optimizations
            qWarning("TrackPixmap::setOffset(): oh nooo, "\
                "offset %u is misaligned by %u sample(s), please fix this!",
                offset, offset % pixels2samples(1));
            qWarning("TrackPixmap::setOffset(): "\
                "now I have to throw away the whole buffer :-((");

            qDebug("TrackPixmap::setOffset(%u): "\
                "misaligned->invalidating buffer", offset);
#endif
            invalidateBuffer();
        } else if (offset > m_offset) {
            // move left
            int diff = samples2pixels(offset - m_offset);
//          qDebug("TrackPixmap::setOffset(): moving left (min/max): %u",diff);
            Q_ASSERT(diff);
            Q_ASSERT(buflen);
            if (diff && buflen) {
                unsigned int src = Kwave::toUint(diff);
                unsigned int dst = 0;
                while (src < buflen) {
                    m_min_buffer[dst] = m_min_buffer[src];
                    m_max_buffer[dst] = m_max_buffer[src];
                    m_valid[dst++]    = m_valid[src++];
                }
                while (dst < buflen) m_valid.clearBit(dst++);
            }
        } else {
            // move right
            int diff = Kwave::toInt(samples2pixels(m_offset - offset));
//          qDebug("TrackPixmap::setOffset(): moving right (min/max): %u",diff);
            Q_ASSERT(diff);
            Q_ASSERT(buflen);
            if (diff && buflen) {
                int dst = buflen - 1;
                while (dst >= diff) {
                    int src = dst - diff;
                    m_min_buffer[dst] = m_min_buffer[src];
                    m_max_buffer[dst] = m_max_buffer[src];
                    m_valid[dst--]    = m_valid[src--];
                }
                diff = dst + 1;
                while (diff--) m_valid.clearBit(dst--);
            }
        }
    } else {
        // move content of sample buffer
        // one buffer element = one sample
        Q_ASSERT(buflen == m_sample_buffer.size());

        if (offset > m_offset) {
            // move left
//          qDebug("TrackPixmap::setOffset(): moving left (normal)");
            unsigned int diff = Kwave::toUint(offset - m_offset);
            unsigned int src  = Kwave::toUint(diff);
            unsigned int dst  = 0;
            while (src < buflen) {
                m_sample_buffer[dst] = m_sample_buffer[src];
                m_valid[dst++]       = m_valid[src++];
            }
            while (dst < buflen) m_valid.clearBit(dst++);
        } else {
            // move right
//          qDebug("TrackPixmap::setOffset(): moving right (normal)");
            int diff = Kwave::toInt(m_offset - offset);
            Q_ASSERT(buflen);
            if (buflen) {
                int dst = buflen - 1;
                while (dst >= diff) {
                    int src = dst - diff;
                    m_sample_buffer[dst] = m_sample_buffer[src];
                    m_valid[dst--]       = m_valid[src];
                }
                diff = dst + 1;
                while (diff--) m_valid.clearBit(dst--);
            }
        }
    }

    m_offset = offset;
    m_modified = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setVerticalZoom()

void Kwave::TrackPixmap::setVerticalZoom ( double  zoom )

virtual

Sets a new vertical zoom factor.

Parameters

zoom	new vertical zoom

Definition at line 433 of file TrackPixmap.cpp.

References m_lock_buffer, m_modified, and m_vertical_zoom.

{
    QMutexLocker lock(&m_lock_buffer);

    if (qFuzzyCompare(zoom, m_vertical_zoom)) return;
    m_vertical_zoom = zoom;
    m_modified = true;
}

setZoom

void Kwave::TrackPixmap::setZoom ( double  zoom )

slot

Sets a new zoom factor in samples per pixel. This normally affects the number of visible samples and a redraw of the current view.

Definition at line 218 of file TrackPixmap.cpp.

References invalidateBuffer(), m_lock_buffer, m_minmax_mode, m_modified, m_zoom, and resizeBuffer().

Referenced by Kwave::TrackView::setZoomAndOffset().

{
    QMutexLocker lock(&m_lock_buffer);

    Q_ASSERT(zoom >= 0.0);
    if (qFuzzyCompare(zoom, m_zoom)) return; // no change

//    qDebug("TrackPixmap::setZoom(%0.3f)", zoom);
    if ((zoom > 1.0) && !m_minmax_mode) {
        // switch to min/max mode
//      qDebug("TrackPixmap::setZoom(): switch to min/max mode");
        invalidateBuffer();
        m_minmax_mode = true;
    } else if ((zoom <= 1.0) && m_minmax_mode) {
        // switch to normal mode
//      qDebug("TrackPixmap::setZoom(): switch to normal mode");
        invalidateBuffer();
        m_minmax_mode = false;
    }

    // take the new zoom and resize the buffer
    m_zoom = zoom;
    if (m_minmax_mode) {
        // TODO: some clever caching instead of throwing away everything
        resizeBuffer();
        invalidateBuffer();
    } else {
        resizeBuffer();
    }

    m_modified = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sigModified

void Kwave::TrackPixmap::sigModified ( )

signal

Emitted if the content of the pixmap was modified.

Referenced by slotSamplesDeleted(), slotSamplesInserted(), and slotSamplesModified().

Here is the caller graph for this function:

slotSamplesDeleted

void Kwave::TrackPixmap::slotSamplesDeleted ( Kwave::Track *  src, sample_index_t  offset, sample_index_t  length  )

privateslot

Connected to the track's sigSamplesDeleted.

Parameters

src	source track
offset	position from which the data was removed
length	number of samples deleted

See also

Track::sigSamplesDeleted

Definition at line 738 of file TrackPixmap.cpp.

References convertOverlap(), m_lock_buffer, m_modified, m_valid, sigModified(), and Kwave::toInt().

Referenced by TrackPixmap().

{
    {
        QMutexLocker lock(&m_lock_buffer);

        convertOverlap(offset, length);
        if (!length) return; // false alarm

        // mark all positions from here to right end as "invalid"
        const int first = Kwave::toInt(offset);
        const int last  = m_valid.size();
        Q_ASSERT(first < m_valid.size());
        Q_ASSERT(last  > first);
        m_valid.fill(false, first, last);

        // repaint of the signal is needed
        m_modified = true;
    }

    // notify our owner about changed data -> screen refresh?
    emit sigModified();
}

Here is the call graph for this function:

Here is the caller graph for this function:

slotSamplesInserted

void Kwave::TrackPixmap::slotSamplesInserted ( Kwave::Track *  src, sample_index_t  offset, sample_index_t  length  )

privateslot

Connected to the track's sigSamplesInserted.

Parameters

src	source track
offset	position from which the data was inserted
length	number of samples inserted

See also

Track::sigSamplesInserted

Definition at line 712 of file TrackPixmap.cpp.

References convertOverlap(), m_lock_buffer, m_modified, m_valid, sigModified(), and Kwave::toInt().

Referenced by TrackPixmap().

{
    {
        QMutexLocker lock(&m_lock_buffer);

        convertOverlap(offset, length);
        if (!length) return; // false alarm

        // mark all positions from here to right end as "invalid"
        const int first = Kwave::toInt(offset);
        const int last  = m_valid.size();
        Q_ASSERT(first < m_valid.size());
        Q_ASSERT(last  > first);
        m_valid.fill(false, first, last);

        // repaint of the signal is needed
        m_modified = true;
    }

    // notify our owner about changed data -> screen refresh?
    emit sigModified();
}

Here is the call graph for this function:

Here is the caller graph for this function:

slotSamplesModified

void Kwave::TrackPixmap::slotSamplesModified ( Kwave::Track *  src, sample_index_t  offset, sample_index_t  length  )

privateslot

Connected to the track's sigSamplesModified

Parameters

src	source track
offset	position from which the data was modified
length	number of samples modified

See also

Track::sigSamplesModified

Definition at line 764 of file TrackPixmap.cpp.

References convertOverlap(), m_lock_buffer, m_modified, m_valid, sigModified(), and Kwave::toInt().

Referenced by TrackPixmap().

{
    {
        QMutexLocker lock(&m_lock_buffer);

        convertOverlap(offset, length);
        if (!length) return; // false alarm

        // mark all overlapping positions as "invalid"
        const int first = Kwave::toInt(offset);
        const int last  = Kwave::toInt(offset + length);
        Q_ASSERT(first < m_valid.size());
        Q_ASSERT(last  > first);
        m_valid.fill(false, first, last);

        // repaint of the signal is needed
        m_modified = true;
    }

    // notify our owner about changed data -> screen refresh?
    emit sigModified();
}

Here is the call graph for this function:

Here is the caller graph for this function:

validateBuffer()

bool Kwave::TrackPixmap::validateBuffer ( )

private

Adapts the current mode and size of the buffers and fills all areas that do not contain valid data with fresh samples. In other words: it makes the buffer "valid" and consistent.

Returns

true if the buffer content has changed, false if no invalid samples were found

Definition at line 274 of file TrackPixmap.cpp.

References INTERPOLATION_ZOOM, invalidateBuffer(), Kwave::Track::length(), m_max_buffer, m_min_buffer, m_minmax_mode, m_offset, m_sample_buffer, m_track, m_valid, m_zoom, Kwave::SampleReader::minMax(), Kwave::Track::openReader(), Kwave::SampleReader::read(), Kwave::SampleReader::seek(), Kwave::SinglePassForward, Kwave::SampleArray::size(), and Kwave::toInt().

Referenced by repaint().

{
    int first = 0;
    int last = 0;
    int buflen = m_valid.size();

    sample_index_t left  = m_offset;
    sample_index_t right = (m_track.length()) ? (m_track.length() - 1) : 0;
    Kwave::SampleReader *reader = m_track.openReader(
        Kwave::SinglePassForward, left, right);
    Q_ASSERT(reader);
    if (!reader) return false;

    if (m_minmax_mode) {
        Q_ASSERT(Kwave::toInt(m_min_buffer.size()) == buflen);
        Q_ASSERT(Kwave::toInt(m_max_buffer.size()) == buflen);
    } else {
        Q_ASSERT(Kwave::toInt(m_sample_buffer.size()) == buflen);
    }

    // work-around for missing extra buffer, delete the whole buffer
    // instead. this should not do any harm, in this mode we only
    // have few samples and redrawing will be fast
    if (m_zoom < INTERPOLATION_ZOOM) invalidateBuffer();

    while (first < buflen) {
        // find the first invalid index
        for (first = last; (first < buflen) && m_valid.testBit(first);
                ++first)
        {}

        // break if the first index is out of range
        if (first >= buflen) {
            delete reader;
            return false; // buffer is already ok
        }

        // find the last invalid index
        for (last = first; (last < buflen) && !m_valid[last]; ++last) {
        }

        if (last >= buflen) last = buflen - 1;
        if ((last > first) && (m_valid[last])) --last;

        // fill our array(s) with fresh sample data
        if (m_minmax_mode) {
            // indices are in pixels, convert to samples

            // first sample in first pixel
            sample_index_t s1 = m_offset +
                static_cast<sample_index_t>(floor(first * m_zoom));
            // last sample of last pixel
            sample_index_t s2 = m_offset +
                static_cast<sample_index_t>(floor((last+1) * m_zoom)) - 1;

            while (first <= last) {
                s2 = m_offset + static_cast<sample_index_t>(
                    floor((first + 1) * m_zoom));

                // get min/max for interval [s1...s2]
                sample_t min;
                sample_t max;
                reader->minMax(s1, s2, min, max);

                m_min_buffer[first] = min;
                m_max_buffer[first] = max;
                m_valid.setBit(first);

                // advance to the next position
                ++first;
                s1 = s2 + 1;
            }
        } else {
            // each index is one sample
            // -> read directly into the buffer
            reader->seek(m_offset + first);
            unsigned int count = reader->read(m_sample_buffer,
                first, last - first + 1);
            while (count) {
                m_valid.setBit(first++);
                count--;
            }

            // fill the rest with zeroes
            while (first <= last) {
                m_valid.setBit(first);
                m_sample_buffer[first++] = 0;
            }

        }

        Q_ASSERT(first >= last);
        ++last;
    }

#ifdef DEBUG
    for (first = 0; first < m_valid.size(); first++) {
        if (!m_valid[first]) qWarning("TrackPixmap::validateBuffer(): "\
                "still invalid index: %u", first);
    }
#endif /* DEBUG */

    delete reader;

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

width()

virtual int Kwave::TrackPixmap::width ( ) const

inlinevirtual

Get the width of the pixmap

Returns

the width of the pixmap in pixels

Definition at line 90 of file TrackPixmap.h.

Referenced by drawInterpolatedSignal(), drawOverview(), Kwave::TrackView::paintEvent(), repaint(), and resizeBuffer().

{ return m_pixmap.width(); }

Here is the caller graph for this function:

Member Data Documentation

m_colors

Kwave::Colors::ColorSet Kwave::TrackPixmap::m_colors

private

set of colors for drawing

Definition at line 367 of file TrackPixmap.h.

Referenced by drawInterpolatedSignal(), drawOverview(), and repaint().

m_interpolation_alpha

QVector<double> Kwave::TrackPixmap::m_interpolation_alpha

private

Buffer for filter coefficients of the low pass used for interpolation.

See also

calculateInterpolation()

Definition at line 364 of file TrackPixmap.h.

Referenced by calculateInterpolation(), drawInterpolatedSignal(), and ~TrackPixmap().

m_interpolation_order

int Kwave::TrackPixmap::m_interpolation_order

private

order of the low pass filter used for interpolation

Definition at line 357 of file TrackPixmap.h.

Referenced by calculateInterpolation(), and drawInterpolatedSignal().

m_lock_buffer

QMutex Kwave::TrackPixmap::m_lock_buffer

private

Mutex for exclusive access to the buffers.

Definition at line 352 of file TrackPixmap.h.

Referenced by isModified(), repaint(), resize(), selectionChanged(), setOffset(), setVerticalZoom(), setZoom(), slotSamplesDeleted(), slotSamplesInserted(), slotSamplesModified(), and ~TrackPixmap().

m_max_buffer

Kwave::SampleArray Kwave::TrackPixmap::m_max_buffer

private

Array with maximum sample values, if in min/max mode.

Definition at line 338 of file TrackPixmap.h.

Referenced by drawOverview(), resizeBuffer(), setOffset(), and validateBuffer().

m_min_buffer

Kwave::SampleArray Kwave::TrackPixmap::m_min_buffer

private

Array with minimum sample values, if in min/max mode.

Definition at line 333 of file TrackPixmap.h.

Referenced by drawOverview(), resizeBuffer(), setOffset(), and validateBuffer().

m_minmax_mode

bool Kwave::TrackPixmap::m_minmax_mode

private

If true, we are in min/max mode. This means that m_sample_buffer is not used and m_minmax_buffer contains is used instead.

Definition at line 321 of file TrackPixmap.h.

Referenced by convertOverlap(), drawOverview(), repaint(), resizeBuffer(), setOffset(), setZoom(), and validateBuffer().

m_modified

bool Kwave::TrackPixmap::m_modified

private

Indicates that the buffer content was modified

Definition at line 341 of file TrackPixmap.h.

Referenced by invalidateBuffer(), isModified(), repaint(), resize(), selectionChanged(), setOffset(), setVerticalZoom(), setZoom(), slotSamplesDeleted(), slotSamplesInserted(), and slotSamplesModified().

m_offset

sample_index_t Kwave::TrackPixmap::m_offset

private

Index of the first sample. Needed for converting pixel positions into absolute sample numbers. This is always in units of samples, independent of the current mode!

Definition at line 304 of file TrackPixmap.h.

Referenced by convertOverlap(), repaint(), setOffset(), and validateBuffer().

m_pixmap

QPixmap Kwave::TrackPixmap::m_pixmap

private

The QPixmap with the bitmap data

Definition at line 292 of file TrackPixmap.h.

Referenced by repaint(), and resize().

m_sample_buffer

Kwave::SampleArray Kwave::TrackPixmap::m_sample_buffer

private

Array with samples needed for drawing when not in min/max mode. This might sometimes include one sample before or after the current view.

Definition at line 328 of file TrackPixmap.h.

Referenced by drawInterpolatedSignal(), drawPolyLineSignal(), resizeBuffer(), setOffset(), and validateBuffer().

m_track

Kwave::Track& Kwave::TrackPixmap::m_track

private

Reference to the track with our sample data.

Definition at line 297 of file TrackPixmap.h.

Referenced by repaint(), and validateBuffer().

m_valid

QBitArray Kwave::TrackPixmap::m_valid

private

Array with one bit for each position in the internal buffers. If the bit corresponding to a certain buffer index is set to "1", the position contains valid data, if "0" the content of the buffer is invalid.

Definition at line 349 of file TrackPixmap.h.

Referenced by convertOverlap(), drawInterpolatedSignal(), drawOverview(), invalidateBuffer(), resizeBuffer(), setOffset(), slotSamplesDeleted(), slotSamplesInserted(), slotSamplesModified(), and validateBuffer().

m_vertical_zoom

double Kwave::TrackPixmap::m_vertical_zoom

private

vertical zoom factor. Default is 1.0

Definition at line 315 of file TrackPixmap.h.

Referenced by drawInterpolatedSignal(), drawOverview(), drawPolyLineSignal(), and setVerticalZoom().

m_zoom

double Kwave::TrackPixmap::m_zoom

private

Zoom factor in samples/pixel. Needed for converting sample indices into pixels and vice-versa.

Definition at line 310 of file TrackPixmap.h.

Referenced by calculateInterpolation(), convertOverlap(), drawInterpolatedSignal(), drawPolyLineSignal(), repaint(), setOffset(), setZoom(), and validateBuffer().

---

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

• libgui/TrackPixmap.h
• libgui/TrackPixmap.cpp