Kwave::OverViewCache Class Reference

#include <OverViewCache.h>

Inheritance diagram for Kwave::OverViewCache:

Collaboration diagram for Kwave::OverViewCache:

Classes
struct	MinMax

Public Types
typedef QVector< MinMax >	MinMaxArray

Signals
void	changed ()

Public Member Functions
	OverViewCache (Kwave::SignalManager &signal, sample_index_t src_offset, sample_index_t src_length, const QList< unsigned int > *src_tracks)
virtual	~OverViewCache ()
int	getMinMax (int width, MinMaxArray &minmax)
virtual QImage	getOverView (int width, int height, const QColor &fg, const QColor &bg, double gain=1.0)

Protected Types
enum	CacheState { Invalid = 0, Fuzzy, Valid, Unused }

Protected Slots
void	slotTrackInserted (const QUuid &track_id)
void	slotTrackDeleted (const QUuid &track_id)
void	slotLengthChanged (sample_index_t new_length)
void	slotInvalidated (const QUuid *track_id, sample_index_t first, sample_index_t last)

Private Member Functions
void	scaleUp ()
void	scaleDown ()
void	invalidateCache (const QUuid *uuid, unsigned int first, unsigned int last)

Private Attributes
Kwave::SignalManager &	m_signal
Kwave::SelectionTracker	m_selection
QHash< QUuid, QVector< sample_t > >	m_min
QHash< QUuid, QVector< sample_t > >	m_max
QHash< QUuid, QVector< CacheState > >	m_state
MinMaxArray	m_minmax
quint64	m_scale
QMutex	m_lock

Detailed Description

Fixed-size cache for multi-track sample data. Automatically updates itself if data has been changed, inserted or deleted. Optimized for speed!

Definition at line 50 of file OverViewCache.h.

Member Typedef Documentation

MinMaxArray

typedef QVector<MinMax> Kwave::OverViewCache::MinMaxArray

Definition at line 60 of file OverViewCache.h.

Member Enumeration Documentation

CacheState

enum Kwave::OverViewCache::CacheState

protected

State of a cache entry

Enumerator
Invalid
Fuzzy
Valid
Unused

Definition at line 142 of file OverViewCache.h.

                     {
            Invalid = 0,
            Fuzzy,
            Valid,
            Unused
        } CacheState;

Constructor & Destructor Documentation

OverViewCache()

Kwave::OverViewCache::OverViewCache	(	Kwave::SignalManager &	signal,
		sample_index_t	src_offset,
		sample_index_t	src_length,
		const QList< unsigned int > *	src_tracks
	)

Constructor

Parameters

signal	reference to a SignalManager with the source
src_offset	first sample index in the source. optional, default=0
src_length	number of samples in the source. optional, default=0 (whole signal)
src_tracks	list of selected source tracks optional, default=0 (whole signal)

Definition at line 37 of file OverViewCache.cpp.

References Kwave::SelectionTracker::allTracks(), Kwave::connect(), m_selection, slotInvalidated(), slotLengthChanged(), slotTrackDeleted(), and slotTrackInserted().

    :m_signal(signal),
     m_selection(&signal, src_offset, src_length, src_tracks),
     m_min(), m_max(), m_state(), m_minmax(),
     m_scale(1),
     m_lock(QMutex::Recursive)
{

    connect(&m_selection, SIGNAL(sigTrackInserted(QUuid)),
            this,         SLOT(slotTrackInserted(QUuid)));
    connect(&m_selection, SIGNAL(sigTrackDeleted(QUuid)),
            this,         SLOT(slotTrackDeleted(QUuid)));
    connect(&m_selection, SIGNAL(sigLengthChanged(sample_index_t)),
            this,         SLOT(slotLengthChanged(sample_index_t)));
    connect(
        &m_selection,
        SIGNAL(sigInvalidated(const QUuid*,sample_index_t,sample_index_t)),
        this,
        SLOT(slotInvalidated(const QUuid*,sample_index_t,sample_index_t))
    );

    // take over the initial list of tracks
    foreach (const QUuid &uuid, m_selection.allTracks())
        slotTrackInserted(uuid);
}

Here is the call graph for this function:

~OverViewCache()

Kwave::OverViewCache::~OverViewCache ( )

virtual

Destructor

Definition at line 67 of file OverViewCache.cpp.

References m_lock, m_max, m_min, and m_state.

{
    QMutexLocker lock(&m_lock);

    m_state.clear();
    m_min.clear();
    m_max.clear();
}

Member Function Documentation

changed

void Kwave::OverViewCache::changed ( )

signal

emitted whenever the cache content has changed

Referenced by slotInvalidated(), slotTrackDeleted(), and slotTrackInserted().

Here is the caller graph for this function:

getMinMax()

int Kwave::OverViewCache::getMinMax	(	int	width,
		MinMaxArray &	minmax
	)

Get an array with min/max sample values

Parameters

width	number of min/max entries to fill
minmax	array that receives the minmax values

Returns

number of successfully filled min/max entries

Definition at line 258 of file OverViewCache.cpp.

References Kwave::SelectionTracker::allTracks(), Kwave::SignalManager::allTracks(), CACHE_SIZE, Kwave::MultiTrackReader::isEmpty(), Kwave::SelectionTracker::last(), Kwave::SelectionTracker::length(), m_lock, m_max, m_min, m_scale, m_selection, m_signal, m_state, Kwave::SampleReader::minMax(), Kwave::SelectionTracker::offset(), SAMPLE_MAX, SAMPLE_MIN, Kwave::SinglePassForward, Kwave::toUint(), Unused, Kwave::SignalManager::uuidOfTrack(), and Valid.

Referenced by getOverView(), and Kwave::NoiseDialog::updateDisplay().

{
    QMutexLocker lock(&m_lock);
    int retval = 0;

    const sample_index_t first  = m_selection.offset();
    const sample_index_t last   = m_selection.last();
    const sample_index_t length = m_selection.length();
    if (!length)
        return 0;

    // resize the target buffer if necessary
    if (minmax.count() < width)
        minmax.resize(width);
    if (minmax.count() < width) // truncated, OOM
        width = minmax.count();

    QList<unsigned int> track_list;
    const QList<QUuid> selected_tracks = m_selection.allTracks();
    foreach (unsigned int track, m_signal.allTracks())
        if (selected_tracks.contains(m_signal.uuidOfTrack(track)))
            track_list.append(track);
    if (track_list.isEmpty())
        return 0;

    Kwave::MultiTrackReader src(
        Kwave::SinglePassForward,
        m_signal, track_list, first, last
    );
    Q_ASSERT(m_min.count() == m_max.count());
    Q_ASSERT(m_min.count() == m_state.count());

    if ((length / m_scale < 2) || src.isEmpty() || !m_state.count())
        return 0; // empty ?

    // loop over all min/max buffers and make their content valid
    for (int index = 0; index < track_list.count(); ++index) {
        unsigned int count = qBound<unsigned int>(
            1, Kwave::toUint(length / m_scale), CACHE_SIZE);

        QUuid uuid = m_signal.uuidOfTrack(track_list[index]);
        if (uuid.isNull()) continue; // track has just been deleted

        // check: maybe slotTrackInserted has not yet been called
        //        or slotTrackDeleted has just been called
        if (!m_state.keys().contains(uuid))
            continue;

        sample_t *min = m_min[uuid].data();
        sample_t *max = m_max[uuid].data();
        CacheState *state = m_state[uuid].data();
        Q_ASSERT(min && max && state);
        Kwave::SampleReader *reader = src[index];
        Q_ASSERT(reader);

        if (!reader || !min || !max || !state) continue;

        for (unsigned int ofs = 0; ofs < count; ++ofs) {
            if (state[ofs] == Valid)  continue;
            if (state[ofs] == Unused) continue;

            // get min/max
            sample_index_t first_idx = m_selection.offset() + (ofs * m_scale);
            sample_index_t last_idx  = first_idx + m_scale - 1;
            reader->minMax(first_idx, last_idx, min[ofs], max[ofs]);
            state[ofs] = Valid;
        }
    }

    // loop over all min/max buffers
    for (int x = 0; x < width; ++x) {
        unsigned int count = qBound<unsigned int>(
            1, Kwave::toUint(length / m_scale), CACHE_SIZE);

        // get the corresponding cache index
        unsigned int index = ((count - 1) * x) / (width - 1);
        unsigned int last_index  = ((count - 1) * (x + 1)) / (width - 1);
        Q_ASSERT(index < CACHE_SIZE);
        if (index >= CACHE_SIZE) index = CACHE_SIZE - 1;
        if (last_index > index) last_index--;
        if (last_index >= CACHE_SIZE) last_index = CACHE_SIZE - 1;

        // loop over all cache indices
        sample_t minimum = SAMPLE_MAX;
        sample_t maximum = SAMPLE_MIN;
        for (; index <= last_index; ++index) {
            // loop over all tracks
            foreach (const QUuid &uuid, m_state.keys()) {
                sample_t *min = m_min[uuid].data();
                sample_t *max = m_max[uuid].data();
                const CacheState *state = m_state[uuid].constData();
                Q_ASSERT(state);
                if (!state) continue;
                if (state[index] != Valid) {
                    if (minimum > 0) minimum = 0;
                    if (maximum < 0) maximum = 0;
                    continue;
                }

                if (min[index] < minimum) minimum = min[index];
                if (max[index] > maximum) maximum = max[index];
            }
        }

        minmax[x].min = minimum;
        minmax[x].max = maximum;
        retval++;
    }

    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getOverView()

QImage Kwave::OverViewCache::getOverView ( int  width, int  height, const QColor &  fg, const QColor &  bg, double  gain = 1.0  )

virtual

Renders an overview into a QImage.

Parameters

width	the width of the bitmap in pixels
height	the width of the bitmap in pixels
fg	foreground color
bg	background color
gain	additional y scaling factor (optional, default = 1.0)

Returns

the created bitmap

Definition at line 371 of file OverViewCache.cpp.

References getMinMax(), m_lock, m_minmax, SAMPLE_MAX, and Kwave::toInt().

Referenced by Kwave::OverViewWidget::calculateBitmap(), Kwave::SonagramPlugin::refreshOverview(), and Kwave::VolumeDialog::updateDisplay().

{
    QMutexLocker lock(&m_lock);

    QImage bitmap(width, height, QImage::Format_ARGB32_Premultiplied);
    if ((width < 2) || (height < 3) || bitmap.isNull()) return bitmap;

    QPainter p;
    p.begin(&bitmap);
    p.fillRect(bitmap.rect(), bg);
    p.setPen(fg);

    int count = getMinMax(width, m_minmax);
    if (count < 1) {
        p.end();
        return bitmap; // empty ?
    }

    // draw the bitmap
    for (int x = 0; x < count; ++x) {
        const int middle = (height >> 1);
        const double scale = static_cast<double>(middle) /
                             static_cast<double>(SAMPLE_MAX);
        double min = m_minmax[x].min * scale;
        double max = m_minmax[x].max * scale;

        if (gain != 1.0) {
            min *= gain;
            max *= gain;
            if (min < -middle) min = -middle;
            if (min > +middle) min = +middle;
            if (max < -middle) max = -middle;
            if (max > +middle) max = +middle;
        }
        p.drawLine(x, middle - Kwave::toInt(max),
                   x, middle - Kwave::toInt(min));
    }

    p.end();
    return bitmap;
}

Here is the call graph for this function:

Here is the caller graph for this function:

invalidateCache()

void Kwave::OverViewCache::invalidateCache ( const QUuid *  uuid, unsigned int  first, unsigned int  last  )

private

Marks a range of cache entries of a track as invalid

Parameters

uuid	ID of the track to invalidate or null for "all tracks"
first	index of the first entry
last	index of the last entry (will be truncated to CACHE_SIZE-1)

Definition at line 151 of file OverViewCache.cpp.

References CACHE_SIZE, Invalid, and m_state.

Referenced by scaleDown(), slotInvalidated(), and slotTrackInserted().

{
    if (track_id) {
        // invalidate a single track
        Q_ASSERT(m_state.contains(*track_id));
        if (!m_state.contains(*track_id)) return;

        if (last >= CACHE_SIZE) last = CACHE_SIZE - 1;

//      qDebug("OverViewCache[%p]::invalidateCache(%s, %u, %u)",
//             static_cast<void *>(this), DBG(track_id->toString()),
//             first, last);

        for (unsigned int pos = first; pos <= last; ++pos)
            m_state[*track_id][pos] = Invalid;
    } else {
        // invalidate all tracks
        foreach (const QUuid &uuid, m_state.keys())
            invalidateCache(&uuid, first, last);
    }
}

Here is the caller graph for this function:

scaleDown()

void Kwave::OverViewCache::scaleDown ( )

private

Expands the cache to hold less samples per entry. As this process loses accuracy, the cache must be "polished" in a second step.

Definition at line 139 of file OverViewCache.cpp.

References CACHE_SIZE, invalidateCache(), Kwave::SelectionTracker::length(), m_scale, and m_selection.

Referenced by slotLengthChanged(), and slotTrackInserted().

{
    const sample_index_t len = m_selection.length();
    quint64 new_scale = static_cast<quint64>(rint(ceil(len / CACHE_SIZE)));
    if (!new_scale) new_scale = 1;
    if (m_scale == new_scale) return;

    m_scale = new_scale;
    invalidateCache(Q_NULLPTR, 0, CACHE_SIZE - 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

scaleUp()

void Kwave::OverViewCache::scaleUp ( )

private

Compresses the cache to hold more samples per entry.

Definition at line 77 of file OverViewCache.cpp.

References CACHE_SIZE, Kwave::SelectionTracker::length(), m_max, m_min, m_scale, m_selection, m_state, SAMPLE_MAX, SAMPLE_MIN, Kwave::toUint(), and Unused.

Referenced by slotLengthChanged(), and slotTrackInserted().

{
    Q_ASSERT(m_scale);
    if (!m_scale) return;

    // calculate the new scale
    const sample_index_t len = m_selection.length();
    unsigned int shrink = Kwave::toUint(len / (m_scale * CACHE_SIZE));
    while (len > CACHE_SIZE * m_scale * shrink) {
        shrink++;
    }
    if (shrink <= 1) return; // nothing to shrink, just ignore new scale

    // loop over all tracks
    foreach (const QUuid &uuid, m_state.keys()) {
        unsigned int dst = 0;
        unsigned int count = CACHE_SIZE / shrink;
        Q_ASSERT(count <= CACHE_SIZE);

        // source pointers
        sample_t *smin = m_min[uuid].data();
        sample_t *smax = m_max[uuid].data();
        CacheState *sstate = m_state[uuid].data();

        // destination pointers
        sample_t *dmin = smin;
        sample_t *dmax = smax;
        CacheState *dstate = sstate;

        // loop over all entries to be shrinked
        while (dst < count) {
            sample_t min = SAMPLE_MAX;
            sample_t max = SAMPLE_MIN;
            CacheState state = Unused;
            for (unsigned int i = 0; i < shrink; ++i) {
                if (*smin < min) min = *smin;
                if (*smax > max) max = *smax;
                if (*sstate < state) state = *sstate;
                ++smin;
                ++smax;
                ++sstate;
            }
            *dmin = min;
            *dmax = max;
            *dstate = state;
            ++dmin;
            ++dmax;
            ++dstate;
            ++dst;
        }

        // the rest will be unused
        while (dst++ < CACHE_SIZE) {
            *dstate = Unused;
            dstate++;
        }
    }

    m_scale *= shrink;
}

Here is the call graph for this function:

Here is the caller graph for this function:

slotInvalidated

void Kwave::OverViewCache::slotInvalidated ( const QUuid *  track_id, sample_index_t  first, sample_index_t  last  )

protectedslot

Connected to the selection tracker's sigInvalidated.

Parameters

track_id	UUID of the track or null for "all tracks"
first	index of the first invalidated sample
last	index of the last invalidated sample

Definition at line 217 of file OverViewCache.cpp.

References CACHE_SIZE, changed(), invalidateCache(), m_lock, m_scale, m_selection, Kwave::SelectionTracker::offset(), Kwave::round_up(), SAMPLE_INDEX_MAX, and Kwave::toUint().

Referenced by OverViewCache().

{
    QMutexLocker lock(&m_lock);

    // adjust offsets, absolute -> relative
    sample_index_t offset = m_selection.offset();
    Q_ASSERT(first >= offset);
    Q_ASSERT(last  >= offset);
    Q_ASSERT(last  >= first);
    first -= offset;
    last  -= offset;

    unsigned int first_idx = Kwave::toUint(first / m_scale);
    unsigned int last_idx;
    if (last >= (SAMPLE_INDEX_MAX - (m_scale - 1)))
        last_idx = CACHE_SIZE - 1;
    else
        last_idx = Kwave::toUint(
            qMin(Kwave::round_up(last, m_scale) / m_scale,
            quint64(CACHE_SIZE - 1))
        );

    invalidateCache(track_id, first_idx, last_idx);
    emit changed();
}

Here is the call graph for this function:

Here is the caller graph for this function:

slotLengthChanged

void Kwave::OverViewCache::slotLengthChanged ( sample_index_t  new_length )

protectedslot

Connected to the selection tracker's sigLengthChanged.

Parameters

new_length

new length of the selection in samples

See also

SelectionTracker::sigLengthChanged

Definition at line 246 of file OverViewCache.cpp.

References CACHE_SIZE, m_lock, m_scale, scaleDown(), and scaleUp().

Referenced by OverViewCache().

{
    QMutexLocker lock(&m_lock);

    // just to be sure: check scale again, maybe it was the first track
    if ((new_length / m_scale) > CACHE_SIZE)
        scaleUp();
    if ((new_length / m_scale) < (CACHE_SIZE / 4))
        scaleDown();
}

Here is the call graph for this function:

Here is the caller graph for this function:

slotTrackDeleted

void Kwave::OverViewCache::slotTrackDeleted ( const QUuid &  track_id )

protectedslot

Connected to the selection tracker's sigTrackInserted.

Parameters

track_id

unique ID of the track

See also

SelectionTracker::sigTrackDeleted

Definition at line 205 of file OverViewCache.cpp.

References changed(), m_lock, m_max, m_min, and m_state.

Referenced by OverViewCache().

{
    QMutexLocker lock(&m_lock);

    m_min.remove(track_id);
    m_max.remove(track_id);
    m_state.remove(track_id);

    emit changed();
}

Here is the caller graph for this function:

slotTrackInserted

void Kwave::OverViewCache::slotTrackInserted ( const QUuid &  track_id )

protectedslot

Connected to the selection tracker's sigTrackInserted.

Parameters

track_id

unique ID of the track

See also

SelectionTracker::sigTrackInserted

Definition at line 176 of file OverViewCache.cpp.

References CACHE_SIZE, changed(), invalidateCache(), Kwave::SelectionTracker::length(), m_lock, m_max, m_min, m_scale, m_selection, m_state, SAMPLE_MAX, SAMPLE_MIN, scaleDown(), scaleUp(), and Unused.

Referenced by OverViewCache().

{
    QMutexLocker lock(&m_lock);

    // just to be sure: check scale again, maybe it was the first track
    if ((m_selection.length() / m_scale) > CACHE_SIZE)
        scaleUp();
    if ((m_selection.length() / m_scale) < (CACHE_SIZE / 4))
        scaleDown();

    QVector<CacheState> state(CACHE_SIZE);
    QVector<sample_t> min(CACHE_SIZE);
    QVector<sample_t> max(CACHE_SIZE);

    min.fill(SAMPLE_MAX);
    max.fill(SAMPLE_MIN);
    state.fill(Unused);

    m_min.insert(track_id, min);
    m_max.insert(track_id, max);
    m_state.insert(track_id, state);

    // mark the new cache content as invalid
    invalidateCache(&track_id, 0, CACHE_SIZE - 1);

    emit changed();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_lock

QMutex Kwave::OverViewCache::m_lock

private

mutex for threadsafe access to the cache

Definition at line 197 of file OverViewCache.h.

Referenced by getMinMax(), getOverView(), slotInvalidated(), slotLengthChanged(), slotTrackDeleted(), slotTrackInserted(), and ~OverViewCache().

m_max

QHash<QUuid, QVector <sample_t> > Kwave::OverViewCache::m_max

private

list of maximum value arrays, one array per track

Definition at line 185 of file OverViewCache.h.

Referenced by getMinMax(), scaleUp(), slotTrackDeleted(), slotTrackInserted(), and ~OverViewCache().

m_min

QHash<QUuid, QVector <sample_t> > Kwave::OverViewCache::m_min

private

list of minimum value arrays, one array per track

Definition at line 182 of file OverViewCache.h.

Referenced by getMinMax(), scaleUp(), slotTrackDeleted(), slotTrackInserted(), and ~OverViewCache().

m_minmax

MinMaxArray Kwave::OverViewCache::m_minmax

private

list of min/max pairs, cached internally for getOverView

Definition at line 191 of file OverViewCache.h.

Referenced by getOverView().

m_scale

quint64 Kwave::OverViewCache::m_scale

private

number of samples per cache entry

Definition at line 194 of file OverViewCache.h.

Referenced by getMinMax(), scaleDown(), scaleUp(), slotInvalidated(), slotLengthChanged(), and slotTrackInserted().

m_selection

Kwave::SelectionTracker Kwave::OverViewCache::m_selection

private

selection tracker

Definition at line 179 of file OverViewCache.h.

Referenced by getMinMax(), OverViewCache(), scaleDown(), scaleUp(), slotInvalidated(), and slotTrackInserted().

m_signal

Kwave::SignalManager& Kwave::OverViewCache::m_signal

private

signal with the data to be shown

Definition at line 176 of file OverViewCache.h.

Referenced by getMinMax().

m_state

QHash<QUuid, QVector <CacheState> > Kwave::OverViewCache::m_state

private

bitmask for "validity" of the min/max values

Definition at line 188 of file OverViewCache.h.

Referenced by getMinMax(), invalidateCache(), scaleUp(), slotTrackDeleted(), slotTrackInserted(), and ~OverViewCache().

---

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

• libgui/OverViewCache.h
• libgui/OverViewCache.cpp