Kwave::Stripe Class Reference

#include <Stripe.h>

Collaboration diagram for Kwave::Stripe:

Classes
class	List
class	MappedArray
class	StripeStorage

Public Member Functions
	Stripe ()
	Stripe (const Stripe &other)
	Stripe (sample_index_t start)
	Stripe (sample_index_t start, const Kwave::SampleArray &samples)
	Stripe (sample_index_t start, Stripe &stripe, unsigned int offset)
virtual	~Stripe ()
sample_index_t	start () const
void	setStart (sample_index_t start)
unsigned int	length () const
sample_index_t	end () const
unsigned int	resize (unsigned int length, bool initialize=true)
unsigned int	append (const Kwave::SampleArray &samples, unsigned int offset, unsigned int count)
void	deleteRange (unsigned int offset, unsigned int length)
void	overwrite (unsigned int offset, const Kwave::SampleArray &source, unsigned int srcoff, unsigned int srclen)
bool	combine (unsigned int offset, Kwave::Stripe &other)
unsigned int	read (Kwave::SampleArray &buffer, unsigned int dstoff, unsigned int offset, unsigned int length)
void	minMax (unsigned int first, unsigned int last, sample_t &min, sample_t &max)
Stripe &	operator<< (const Kwave::SampleArray &samples)
bool	operator== (const Stripe &other) const
Stripe &	operator= (const Stripe &other)

Private Member Functions
unsigned int	resizeStorage (unsigned int length)
sample_t *	mapStorage ()
void	unmapStorage ()

Private Attributes
QMutex	m_lock
QExplicitlySharedDataPointer< StripeStorage >	m_data

Detailed Description

Definition at line 35 of file Stripe.h.

Constructor & Destructor Documentation

Stripe() [1/5]

Kwave::Stripe::Stripe

(

)

Default constructor. Creates an empty stripe with zero-length.

Definition at line 204 of file Stripe.cpp.

    :m_lock(), m_data(new(std::nothrow) StripeStorage)
{
}

Stripe() [2/5]

Kwave::Stripe::Stripe

(

const Stripe &

other

)

Copy constructor

Definition at line 210 of file Stripe.cpp.

References m_data.

    :m_lock(), m_data(Q_NULLPTR)
{
    m_data = other.m_data;
}

Stripe() [3/5]

Kwave::Stripe::Stripe

(

sample_index_t

start

)

Constructor. Creates a new zero-length stripe.

Parameters

start

position within the track

Definition at line 217 of file Stripe.cpp.

References m_data, and start().

    :m_lock(), m_data(new(std::nothrow) StripeStorage)
{
    if (m_data) m_data->m_start = start;
}

Here is the call graph for this function:

Stripe() [4/5]

Kwave::Stripe::Stripe	(	sample_index_t	start,
		const Kwave::SampleArray &	samples
	)

Constructor. Creates a stripe that already contains samples, copied from a buffer with samples.

Parameters

start	position within the track
samples	array with initial samples

Definition at line 224 of file Stripe.cpp.

References append(), m_data, Kwave::SampleArray::size(), and start().

    :m_lock(), m_data(new(std::nothrow) StripeStorage)
{
    if (m_data) m_data->m_start = start;
    if (samples.size()) append(samples, 0, samples.size());
}

Here is the call graph for this function:

Stripe() [5/5]

Kwave::Stripe::Stripe	(	sample_index_t	start,
		Kwave::Stripe &	stripe,
		unsigned int	offset
	)

Constructor. Creates a stripe that already contains samples, copied from another stripe with offset.

Parameters

start	position within the track
stripe	source stripe to copy from
offset	offset within the source stripe

Definition at line 232 of file Stripe.cpp.

References Kwave::SampleArray::data(), length(), m_data, read(), resize(), resizeStorage(), and start().

    :m_lock(), m_data(new(std::nothrow) StripeStorage)
{
    if (!m_data) return;

    m_data->m_start = start;

    Q_ASSERT(offset < stripe.length());
    if (offset >= stripe.length()) return;

    unsigned int length = stripe.length() - offset;
    if (resizeStorage(length) != length) return; // out of memory

    if (length) {
        MappedArray _samples(*this);
        Q_ASSERT(_samples.data());
        if (!_samples.data()) return; // OOM
        if (!stripe.read(_samples, 0, offset, length)) resize(0);
    }
}

Here is the call graph for this function:

~Stripe()

Kwave::Stripe::~Stripe ( )

virtual

Destructor.

Definition at line 256 of file Stripe.cpp.

References m_lock.

{
    QMutexLocker lock(&m_lock);
}

Member Function Documentation

append()

unsigned int Kwave::Stripe::append	(	const Kwave::SampleArray &	samples,
		unsigned int	offset,
		unsigned int	count
	)

Appends an array of samples to the end of the stripe.

Parameters

samples	array with the samples
offset	the offset within the array
count	number of samples in the array

Returns

number of samples appended

Definition at line 381 of file Stripe.cpp.

References Kwave::MemoryManager::instance(), m_data, m_lock, resizeStorage(), Kwave::SampleArray::size(), and Kwave::MemoryManager::writeTo().

Referenced by Kwave::Track::appendAfter(), operator<<(), and Stripe().

{
    if (!count) return 0; // nothing to do
    Q_ASSERT(offset + count <= samples.size());
    if (offset + count > samples.size()) return 0;

//     qDebug("Stripe::append: adding %d samples", count);
    QMutexLocker lock(&m_lock);
    m_data.detach();
    if (!m_data) return 0; // OOM when detaching

    unsigned int old_length = m_data->m_length;
    unsigned int new_length = old_length + count;
    Q_ASSERT(!m_data->mapCount());
    if (resizeStorage(new_length) != new_length)
        return 0; // out of memory

    // append to the end of the area
    unsigned int cnt = new_length - old_length;
    Q_ASSERT(!m_data->mapCount());
    int bytes_appended = Kwave::MemoryManager::instance().writeTo(
        m_data->m_storage,
        old_length * sizeof(sample_t),
        &(samples[offset]), cnt * sizeof(sample_t)
    );

//     qDebug("Stripe::append(): resized to %d", m_length);
    return (bytes_appended > 0) ? (bytes_appended / sizeof(sample_t)) : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

combine()

bool Kwave::Stripe::combine	(	unsigned int	offset,
		Kwave::Stripe &	other
	)

Combine this stripe with another stripe

Parameters

offset	the offset within this stripe to put the other stripe
other	reference to another stripe

Returns

true if succeeded or false if failed (e.g. out of memory)

Definition at line 457 of file Stripe.cpp.

References Kwave::SampleArray::constData(), Kwave::SampleArray::data(), length(), m_data, m_lock, MEMCPY, resizeStorage(), and Kwave::SampleArray::size().

Referenced by Kwave::Track::defragment().

{
    QMutexLocker lock(&m_lock);
    m_data.detach();
    if (!m_data) return false; // OOM when detaching

    if (m_data->mapCount()) return false; // data is mapped

    const unsigned int old_len      = m_data->m_length;
    const unsigned int combined_len = offset + other.length();
    if (old_len < combined_len) {
        // resize the storage if necessary
        if (resizeStorage(combined_len) != combined_len)
            return false; // resizing failed, maybe OOM ?
    }

    // copy the data from the other stripe
    MappedArray _src(other);
    MappedArray _dst(*this);
    const sample_t *src = _src.constData();
    sample_t       *dst = _dst.data();
    unsigned int    len = _src.size() * sizeof(sample_t);
    if (!src || !dst) return false; // mmap of src or dst failed

    MEMCPY(dst + offset, src, len);

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deleteRange()

void Kwave::Stripe::deleteRange	(	unsigned int	offset,
		unsigned int	length
	)

Deletes a range of samples

Parameters

offset	index of the first sample, relative to the start of the stripe [0...length()-1]
length	number of samples

Definition at line 414 of file Stripe.cpp.

References Kwave::Stripe::MappedArray::copy(), m_data, m_lock, and resizeStorage().

Referenced by Kwave::Track::stripes(), and Kwave::Track::unlockedDelete().

{
//     qDebug("    Stripe::deleteRange(offset=%u, length=%u)", offset, length);
    if (!length) return; // nothing to do

    QMutexLocker lock(&m_lock);
    m_data.detach();
    if (!m_data) return; // OOM when detaching

    const unsigned int size = m_data->m_length;
    if (!size) return;

    unsigned int first = offset;
    unsigned int last  = offset + length - 1;
//     qDebug("    Stripe::deleteRange, me=[%u ... %u] del=[%u ... %u]",
//          m_start, m_start+size-1, m_start + first, m_start + last);

    Q_ASSERT(first < size);
    if (first >= size) return;

    // put first/last into our area
    if (last >= size) last = size - 1;
    Q_ASSERT(last >= first);
    if (last < first) return;

    // move all samples after the deleted area to the left
    unsigned int dst = first;
    unsigned int src = last+1;
    unsigned int len = size - src;
//     qDebug("    Stripe: deleting %u ... %u", dst, src-1);
    if (len) {
        MappedArray _samples(*this);

        Q_ASSERT(src + len <= size);
        Q_ASSERT(dst + len <= size);
        if (!_samples.copy(dst, src, len)) return;
    }

    // resize the buffer to it's new size
    resizeStorage(size - length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

end()

sample_index_t Kwave::Stripe::end

(

)

const

Returns the position of the last sample of the stripe, same as (start() + length() ? (length() - 1))

Definition at line 282 of file Stripe.cpp.

References m_data.

Referenced by Kwave::Track::appendAfter(), Kwave::Track::defragment(), Kwave::Track::dump(), Kwave::Track::insertSpace(), Kwave::Track::mergeStripe(), Kwave::SampleReader::minMax(), operator==(), Kwave::SampleReader::readSamples(), Kwave::DebugPlugin::run(), Kwave::Track::stripes(), Kwave::Track::unlockedDelete(), and Kwave::Track::writeSamples().

{
    return (m_data) ? (m_data->m_start +
        ((m_data->m_length) ? (m_data->m_length - 1) : 0)) : 0;
}

Here is the caller graph for this function:

length()

unsigned int Kwave::Stripe::length

(

)

const

Returns the current length of the stripe in samples.

Definition at line 276 of file Stripe.cpp.

References m_data.

Referenced by Kwave::Track::appendAfter(), combine(), Kwave::Track::defragment(), Kwave::Track::dump(), Kwave::Track::insertSpace(), Kwave::SampleReader::minMax(), Kwave::Stripe::MappedArray::read(), Kwave::SampleReader::readSamples(), resize(), resizeStorage(), Kwave::Track::splitStripe(), Stripe(), Kwave::Track::stripes(), Kwave::Track::Track(), Kwave::Track::unlockedDelete(), Kwave::Track::unlockedLength(), and Kwave::Track::writeSamples().

{
    return (m_data) ? m_data->m_length : 0;
}

Here is the caller graph for this function:

mapStorage()

sample_t * Kwave::Stripe::mapStorage ( )

private

maps the storage into memory

Definition at line 601 of file Stripe.cpp.

References m_data.

Referenced by Kwave::Stripe::MappedArray::MappedArray().

{
    return (m_data) ? m_data->map() : Q_NULLPTR;
}

Here is the caller graph for this function:

minMax()

void Kwave::Stripe::minMax	(	unsigned int	first,
		unsigned int	last,
		sample_t &	min,
		sample_t &	max
	)

Returns the minimum and maximum sample value within a range of samples.

Parameters

first	index of the first sample
last	index of the last sample
min	receives the lowest value (must be initialized)
max	receives the highest value (must be initialized)

Definition at line 537 of file Stripe.cpp.

References Kwave::SampleArray::constData(), m_data, and m_lock.

Referenced by Kwave::SampleReader::minMax().

{
    QMutexLocker lock(&m_lock);
    if (!m_data) return;

    MappedArray _samples(*this);
    const sample_t *buffer = _samples.constData();
    if (!buffer) return;

    // loop over the mapped storage to get min/max
    sample_t lo = min;
    sample_t hi = max;
    Q_ASSERT(first < m_data->m_length);
    Q_ASSERT(first <= last);
    Q_ASSERT(last < m_data->m_length);
    buffer += first;
    unsigned int remaining = last - first + 1;

    // speedup: process a block of 8 samples at once, to allow loop unrolling
    const unsigned int block = 8;
    while (Q_LIKELY(remaining >= block)) {
        for (unsigned int count = 0; Q_LIKELY(count < block); count++) {
            sample_t s = *(buffer++);
            if (Q_UNLIKELY(s < lo)) lo = s;
            if (Q_UNLIKELY(s > hi)) hi = s;
        }
        remaining -= block;
    }
    while (Q_LIKELY(remaining)) {
        sample_t s = *(buffer++);
        if (Q_UNLIKELY(s < lo)) lo = s;
        if (Q_UNLIKELY(s > hi)) hi = s;
        remaining--;
    }
    min = lo;
    max = hi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<()

Kwave::Stripe & Kwave::Stripe::operator<<

(

const Kwave::SampleArray &

samples

)

Operator for appending an array of samples to the end of the stripe.

Definition at line 577 of file Stripe.cpp.

References append(), and Kwave::SampleArray::size().

{
    unsigned int appended = append(samples, 0, samples.size());
    if (appended != samples.size()) {
        qWarning("Stripe::operator << FAILED");
    }
    return *this;
}

Here is the call graph for this function:

operator=()

Kwave::Stripe & Kwave::Stripe::operator=

(

const Stripe &

other

)

assignment operator

Definition at line 594 of file Stripe.cpp.

References m_data.

{
    m_data = other.m_data;
    return *this;
}

operator==()

bool Kwave::Stripe::operator==

(

const Stripe &

other

)

const

compare operator

Definition at line 587 of file Stripe.cpp.

References end(), and start().

{
    return ((start() == other.start()) &&
            (end()   == other.end()));
}

Here is the call graph for this function:

overwrite()

void Kwave::Stripe::overwrite	(	unsigned int	offset,
		const Kwave::SampleArray &	source,
		unsigned int	srcoff,
		unsigned int	srclen
	)

Copies the content of an array of samples into the stripe.

Parameters

offset	the offset within the stripe (target)
source	array of samples to be copied
srcoff	offset within the source array
srclen	length of the data in the source array

Warning

this method is intended to be used only internally and lacks any error-checking in order to be fast!

Definition at line 487 of file Stripe.cpp.

References Kwave::MemoryManager::instance(), m_data, m_lock, and Kwave::MemoryManager::writeTo().

{
    QMutexLocker lock(&m_lock);
    m_data.detach();
    if (!m_data) return; // OOM when detaching

    Q_ASSERT(!m_data->mapCount());
    Kwave::MemoryManager::instance().writeTo(m_data->m_storage,
        offset * sizeof(sample_t),
        &(source[srcoff]), srclen * sizeof(sample_t));
}

Here is the call graph for this function:

read()

unsigned int Kwave::Stripe::read	(	Kwave::SampleArray &	buffer,
		unsigned int	dstoff,
		unsigned int	offset,
		unsigned int	length
	)

Reads out samples from the stripe into a buffer

Parameters

buffer	array for samples to be read (destination)
dstoff	offset within the destination buffer
offset	the offset within the stripe (source)
length	number of samples to read

Returns

number of samples read

Warning

this method is intended to be used only internally and lacks any error-checking in order to be fast!

Definition at line 502 of file Stripe.cpp.

References Kwave::MemoryManager::instance(), m_data, m_lock, and Kwave::MemoryManager::readFrom().

Referenced by Kwave::SampleReader::readSamples(), Stripe(), and Kwave::Stripe::StripeStorage::StripeStorage().

{
    QMutexLocker lock(&m_lock);
    if (!length || !m_data) return 0; // nothing to do !?

//  for (unsigned int x=dstoff; (dstoff+x < length) && (x < buffer.size()); x++)
//      buffer[x] = -(SAMPLE_MAX >> 2);

//     qDebug("Stripe::read(), me=[%u ... %u] (size=%u), offset=%u, length=%u",
//            m_start, m_start+m_length-1, m_length, offset, length);

    Q_ASSERT(offset < m_data->m_length);
    if (offset >= m_data->m_length) return 0;
    if ((offset + length) > m_data->m_length)
        length = m_data->m_length - offset;
    Q_ASSERT(length);
//     if (!length) qDebug("--- [%u ... %u] (%u), offset=%u",
//                         m_start, m_start+m_length-1, m_length, offset);
    if (!length) return 0;

    // read directly through the memory manager, fastest path
    int bytes_read = Kwave::MemoryManager::instance().readFrom(
        m_data->m_storage,
        offset * sizeof(sample_t),
        &buffer[dstoff], length * sizeof(sample_t)
    );

//  qDebug("read done, length=%u", read_len);
    return (bytes_read > 0) ? (bytes_read / sizeof(sample_t)) : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resize()

unsigned int Kwave::Stripe::resize	(	unsigned int	length,
		bool	initialize = true
	)

Resizes the stripe to a new number of samples. If the array size is reduced, samples from the end are thrown away. If the size is increased, samples with zero value will be added to the end.

Parameters

length	new length of the array [samples]
initialize	if true, initialize all new areas with zeroes if the size has been increased (default = true)

Returns

new length [samples]

Definition at line 339 of file Stripe.cpp.

References Kwave::SampleArray::data(), length(), m_data, m_lock, resizeStorage(), and Kwave::SampleArray::size().

Referenced by Kwave::Track::appendStripe(), Kwave::Track::insertSpace(), Kwave::Track::splitStripe(), Stripe(), Kwave::Track::stripes(), and Kwave::Track::Track().

{
    QMutexLocker lock(&m_lock);
    m_data.detach();
    if (!m_data) return 0; // OOM when detaching

    unsigned int old_length = m_data->m_length;
    if (m_data->m_length == length) return old_length; // nothing to do

//     qDebug("Stripe::resize() from %d to %d samples", old_length, length);
    Q_ASSERT(!m_data->mapCount());
    if (resizeStorage(length) != length) {
        qWarning("Stripe::resize(%u) failed, out of memory ?", length);
        return m_data->m_length;
    }

    // fill new samples with zero
    if (initialize && length) {
        Q_ASSERT(!m_data->mapCount());
        unsigned int pos = old_length;

#ifdef STRICTLY_QT
        MappedArray _samples(*this);
        if (_samples.size() != m_data->m_length) return 0;

        while (pos < length) {
            _samples[pos++] = 0;
        }
#else
        MappedArray _map(*this);
        sample_t *samples = _map.data();
        if (!samples) return 0;
        if (pos < length) {
            memset(&(samples[pos]), 0, (length - pos) * sizeof(sample_t));
        }
#endif
    }

    return length;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resizeStorage()

unsigned int Kwave::Stripe::resizeStorage ( unsigned int  length )

private

Resizes the internal storage.

Parameters

length

the new length in samples

Returns

the length after the resize operation. Should be equal to the length that has been given as parameter. If not, something has failed.

Note

called internally only, under lock. It is made sure that m_data is already detached and not null

Definition at line 289 of file Stripe.cpp.

References Kwave::MemoryManager::free(), Kwave::MemoryManager::instance(), length(), and m_data.

Referenced by append(), combine(), deleteRange(), resize(), and Stripe().

{
    Q_ASSERT(m_data); // (just paranoia)

    if (m_data->m_length == length) return length; // nothing to do
//     qDebug("Stripe::resizeStorage(%u)", length);

    // check: must not be mapped!
    Q_ASSERT(!m_data->mapCount());
    if (m_data->mapCount()) return m_data->m_length;

    Kwave::MemoryManager &mem = Kwave::MemoryManager::instance();

    // special case: zero length means delete
    if (length == 0) {
        // delete the array
        mem.free(m_data->m_storage);
        m_data->m_storage = 0;
        m_data->m_length  = 0;
        return 0;
    }

    if (!m_data->m_length || !m_data->m_storage) {
        // allocate new storage
        Kwave::Handle new_storage = mem.allocate(length * sizeof(sample_t));
        if (!new_storage) {
            // allocation failed
            qWarning("Stripe::resizeStorage(%u) failed! (1)", length);
            return m_data->m_length;
        }

        Q_ASSERT(!m_data->m_storage);
        m_data->m_storage = new_storage;
        m_data->m_length  = length;
        return length;
    }

    // resize the array to another size
    if (!mem.resize(m_data->m_storage, length * sizeof(sample_t))) {
        // resize failed
        qWarning("Stripe::resizeStorage(%u) failed! (2)", length);
        return m_data->m_length;
    }

    // succeeded
    m_data->m_length  = length;
    return length;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setStart()

void Kwave::Stripe::setStart

(

sample_index_t

start

)

Sets a new start position for the stripe

Definition at line 268 of file Stripe.cpp.

References m_data, m_lock, and start().

Referenced by Kwave::Track::moveRight(), Kwave::Track::stripes(), and Kwave::Track::unlockedDelete().

{
    QMutexLocker lock(&m_lock);
    m_data.detach();
    if (m_data) m_data->m_start = start;
}

Here is the call graph for this function:

Here is the caller graph for this function:

start()

sample_index_t Kwave::Stripe::start

(

)

const

Returns the start position of the stripe within the track.

Definition at line 262 of file Stripe.cpp.

References m_data.

Referenced by Kwave::Track::defragment(), Kwave::Track::dump(), Kwave::Track::insertSpace(), Kwave::Track::mergeStripe(), Kwave::SampleReader::minMax(), Kwave::Track::moveRight(), operator==(), Kwave::SampleReader::readSamples(), Kwave::DebugPlugin::run(), setStart(), Kwave::Track::splitStripe(), Stripe(), Kwave::Track::stripes(), Kwave::Track::unlockedDelete(), Kwave::Track::unlockedLength(), and Kwave::Track::writeSamples().

{
    return (m_data) ? m_data->m_start : 0;
}

Here is the caller graph for this function:

unmapStorage()

void Kwave::Stripe::unmapStorage ( )

private

unmaps the storage from memory

Definition at line 607 of file Stripe.cpp.

References m_data.

Referenced by Kwave::Stripe::MappedArray::~MappedArray().

{
    if (m_data) m_data->unmap();
}

Here is the caller graph for this function:

Member Data Documentation

m_data

QExplicitlySharedDataPointer<StripeStorage> Kwave::Stripe::m_data

private

pointer to the shared data

Definition at line 358 of file Stripe.h.

Referenced by append(), combine(), deleteRange(), end(), length(), mapStorage(), minMax(), operator=(), overwrite(), read(), resize(), resizeStorage(), setStart(), start(), Stripe(), and unmapStorage().

m_lock

QMutex Kwave::Stripe::m_lock

private

mutex for locking map/unmap

Definition at line 355 of file Stripe.h.

Referenced by append(), combine(), deleteRange(), minMax(), overwrite(), read(), resize(), setStart(), and ~Stripe().

---

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

• libkwave/Stripe.h
• libkwave/Stripe.cpp