Kwave::Track Class Reference

#include <Track.h>

Inheritance diagram for Kwave::Track:

Collaboration diagram for Kwave::Track:

Public Slots
void	toggleSelection ()
void	defragment ()

Signals
void	sigSamplesInserted (Kwave::Track *src, sample_index_t offset, sample_index_t length)
void	sigSamplesDeleted (Kwave::Track *src, sample_index_t offset, sample_index_t length)
void	sigSamplesModified (Kwave::Track *src, sample_index_t offset, sample_index_t length)
void	sigSelectionChanged (bool selected)

Public Member Functions
	Track ()
	Track (sample_index_t length, QUuid *uuid)
virtual	~Track ()
sample_index_t	length ()
Kwave::Writer *	openWriter (Kwave::InsertMode mode, sample_index_t left=0, sample_index_t right=0)
Kwave::SampleReader *	openReader (Kwave::ReaderMode mode, sample_index_t left=0, sample_index_t right=SAMPLE_INDEX_MAX)
Kwave::Stripe::List	stripes (sample_index_t left, sample_index_t right)
bool	mergeStripes (const Kwave::Stripe::List &stripes)
void	deleteRange (sample_index_t offset, sample_index_t length, bool make_gap=false)
bool	insertSpace (sample_index_t offset, sample_index_t shift)
bool	selected () const
void	select (bool select)
const QUuid &	uuid () const

Protected Member Functions
bool	writeSamples (Kwave::InsertMode mode, sample_index_t offset, const Kwave::SampleArray &buffer, unsigned int buf_offset, unsigned int length)
void	use ()
void	release ()

Private Member Functions
sample_index_t	unlockedLength ()
void	unlockedDelete (sample_index_t offset, sample_index_t length, bool make_gap=false)
bool	appendAfter (Stripe *stripe, sample_index_t offset, const Kwave::SampleArray &buffer, unsigned int buf_offset, unsigned int length)
void	moveRight (sample_index_t offset, sample_index_t shift)
void	appendStripe (sample_index_t length)
Stripe	splitStripe (Stripe &stripe, unsigned int offset)
bool	mergeStripe (Kwave::Stripe &stripe)
void	dump ()
Stripe *	newStripe (sample_index_t start, unsigned int length)

Private Attributes
QMutex	m_lock
QReadWriteLock	m_lock_usage
QList< Stripe >	m_stripes
bool	m_selected
QUuid	m_uuid

Friends
class	Kwave::TrackWriter

Detailed Description

Definition at line 44 of file Track.h.

Constructor & Destructor Documentation

Track() [1/2]

Kwave::Track::Track

(

)

Default constructor. Creates a new and empty track with zero-length, no stripes and new uuid

Definition at line 58 of file Track.cpp.

    :m_lock(QMutex::Recursive), m_lock_usage(), m_stripes(), m_selected(true),
     m_uuid(QUuid::createUuid())
{
}

Track() [2/2]

Kwave::Track::Track	(	sample_index_t	length,
		QUuid *	uuid
	)

Constructor. Creates an empty track with a specified length.

Parameters

length	the length in samples
uuid	unique ID of the track, can be null

Definition at line 65 of file Track.cpp.

References appendStripe(), Kwave::Stripe::length(), m_stripes, Kwave::Stripe::resize(), STRIPE_LENGTH_MAXIMUM, and STRIPE_LENGTH_OPTIMAL.

    :m_lock(QMutex::Recursive), m_lock_usage(), m_stripes(), m_selected(true),
     m_uuid((uuid) ? *uuid : QUuid::createUuid())
{
    if (length < STRIPE_LENGTH_MAXIMUM) {
        if (length) appendStripe(length);
    } else {
        Stripe s(length - STRIPE_LENGTH_OPTIMAL);
        s.resize(STRIPE_LENGTH_OPTIMAL);
        if (s.length()) m_stripes.append(s);
    }
}

Here is the call graph for this function:

~Track()

Kwave::Track::~Track ( )

virtual

Destructor.

Definition at line 79 of file Track.cpp.

References m_lock, m_lock_usage, and m_stripes.

{
    // wait until all readers are finished
    QWriteLocker lock_usage(&m_lock_usage);

    // don't allow any further operation
    QMutexLocker lock(&m_lock);

    // delete all stripes
    m_stripes.clear();
}

Member Function Documentation

appendAfter()

bool Kwave::Track::appendAfter ( Stripe *  stripe, sample_index_t  offset, const Kwave::SampleArray &  buffer, unsigned int  buf_offset, unsigned int  length  )

private

Append samples after a given stripe.

Parameters

stripe	the stripe after which to instert. Null pointer is allowed, in this case a new stripe is created
offset	position where the new data should start
buffer	array with samples
buf_offset	offset within the buffer
length	number of samples to write

Returns

true if successful, false if failed (e.g. out of memory)

Definition at line 478 of file Track.cpp.

References Kwave::Stripe::append(), Kwave::Stripe::end(), length(), Kwave::Stripe::length(), m_stripes, Kwave::SampleArray::size(), STRIPE_LENGTH_MAXIMUM, and Kwave::toUint().

Referenced by writeSamples().

{
    Q_ASSERT(buf_offset + length <= buffer.size());
    if (buf_offset + length > buffer.size()) return false;

    // append to the last stripe if one exists and it's not full
    // and the offset is immediately after the last stripe
    if ((stripe) && (stripe->end()+1 == offset) &&
        (stripe->length() < STRIPE_LENGTH_MAXIMUM))
    {
        unsigned int len = length;
        if (len + stripe->length() > STRIPE_LENGTH_MAXIMUM)
            len = STRIPE_LENGTH_MAXIMUM - stripe->length();

//      qDebug("Kwave::Track::appendAfter(): appending %u samples to %p",
//             len, stripe);
        if (!stripe->append(buffer, buf_offset, len))
            return false; // out of memory

        offset     += len;
        length     -= len;
        buf_offset += len;
    }

    int index_before = (stripe) ? (m_stripes.indexOf(*stripe)) : -1;

    // append new stripes as long as there is something remaining
    while (length) {
        unsigned int len = Kwave::toUint(qMin<sample_index_t>(
            length, STRIPE_LENGTH_MAXIMUM));

//      qDebug("Kwave::Track::appendAfter: new stripe, ofs=%u, len=%u",
//             offset, len);
        Stripe new_stripe(offset);

        // append to the new stripe
        if (!new_stripe.append(buffer, buf_offset, len)) {
            qWarning("Kwave::Track::appendAfter FAILED / OOM");
            return false; /* out of memory */
        }
        Q_ASSERT(new_stripe.length() == len);

//      qDebug("new stripe: [%u ... %u] (%u)", new_stripe->start(),
//             new_stripe->end(), new_stripe->length());

        if (index_before >= 0) {
            // insert after the last one
            index_before++;
//          qDebug("Kwave::Track::appendAfter: insert after %p [%10u - %10u]",
//              stripe, stripe->start(), stripe->end());
            m_stripes.insert(index_before, new_stripe);
        } else {
            // the one and only or insert before all others
//          qDebug("Kwave::Track::appendAfter: prepending");
            m_stripes.prepend(new_stripe);
            index_before = 0;
        }
        offset     += len;
        length     -= len;
        buf_offset += len;
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

appendStripe()

void Kwave::Track::appendStripe ( sample_index_t  length )

private

Append a new stripe with a given length.

Parameters

length

number of samples, zero is allowed

Definition at line 92 of file Track.cpp.

References m_stripes, Kwave::Stripe::resize(), sigSamplesInserted(), STRIPE_LENGTH_MAXIMUM, Kwave::toUint(), and unlockedLength().

Referenced by Track().

{
    sample_index_t start = unlockedLength();
    do {
        unsigned int len = Kwave::toUint(
            qMin<sample_index_t>(STRIPE_LENGTH_MAXIMUM, length));

        Stripe s(start);
        s.resize(len);
        if (len) emit sigSamplesInserted(this, start, len);

        length -= len;
        start  += len;
        m_stripes.append(s);
    } while (length);

}

Here is the call graph for this function:

Here is the caller graph for this function:

defragment

void Kwave::Track::defragment ( )

slot

do some defragmentation of stripes

Definition at line 696 of file Track.cpp.

References Kwave::Stripe::combine(), Kwave::Stripe::end(), Kwave::Stripe::length(), m_lock, m_stripes, Kwave::Stripe::start(), STRIPE_LENGTH_MAXIMUM, STRIPE_LENGTH_MINIMUM, and Kwave::toUint().

Referenced by deleteRange(), mergeStripes(), and openWriter().

{

    if (!m_lock.tryLock()) {
        // this could happen when there are two or more writers
//      qDebug("Track::defragment() - busy");
        return;
    }

    if (m_stripes.count() > 1)
    {
//      qDebug("Track::defragment(), state before:");
//      dump();

//      unsigned int   index  = 0;
        Kwave::Stripe *before = Q_NULLPTR;
        Kwave::Stripe *stripe = Q_NULLPTR;

        // use a quick and simple algorithm:
        // iterate over all stripes and analyze pairwise
        QMutableListIterator<Kwave::Stripe> it(m_stripes);
        while (it.hasNext()) {
            before = stripe;
            stripe = &(it.next());
            if (!before) continue; // skip the first entry
//          index++;

//          qDebug("Track::defragment(), checking #%u [%llu..%llu] (%u)",
//                  index, stripe->start(), stripe->end(), stripe->length());

            const sample_index_t before_start = before->start();
            const sample_index_t stripe_end   = stripe->end();
            const sample_index_t combined_len = stripe_end - before_start + 1;

            if (combined_len > STRIPE_LENGTH_MAXIMUM)
                continue; // would be too large

            if ((before->length() < STRIPE_LENGTH_MINIMUM) ||
                (stripe->length() < STRIPE_LENGTH_MINIMUM)) {
//              qDebug("Track::defragment(), combine #%u [%llu..%llu] & "
//                     "#%u [%llu..%llu] => [%llu..%llu] (%llu)",
//                     index - 1, before->start(), before->end(),
//                     index, stripe->start(), stripe->end(),
//                     before->start(), stripe->end(), combined_len);

                // try to resize the stripe before to contain the
                // combined length
                const unsigned int offset = Kwave::toUint(
                    stripe->start() - before_start);
                if (!before->combine(offset, *stripe))
                    continue; // not possible, maybe OOM ?

                // remove the current stripe, to avoid an overlap
                it.remove();
                stripe = before;
//              index--;
            }
        }

//      qDebug("Track::defragment(), state after:");
//      dump();
    }

    m_lock.unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

deleteRange()

void Kwave::Track::deleteRange	(	sample_index_t	offset,
		sample_index_t	length,
		bool	make_gap = false
	)

Deletes a range of samples

Parameters

offset	index of the first sample
length	number of samples
make_gap	if true, make a gap into the list of stripes instead of moving the stuff from right to left

Note

triggers a defragmentation if make_gap is false

Definition at line 293 of file Track.cpp.

References defragment(), m_lock, sigSamplesDeleted(), and unlockedDelete().

Referenced by Kwave::Signal::deleteRange().

{
    if (!length) return;

//     qDebug("Kwave::Track::deleteRange() [%u ... %u] (%u)",
//      offset, offset + length - 1, length);

    {
        QMutexLocker lock(&m_lock);
        unlockedDelete(offset, length, make_gap);
    }

    // deletion without gap might have left some fragments
    if (!make_gap)
        defragment();

    emit sigSamplesDeleted(this, offset, length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump()

void Kwave::Track::dump ( )

private

dump the list of stripes, for debugging

for debugging only

Definition at line 775 of file Track.cpp.

References Kwave::Stripe::end(), Kwave::Stripe::length(), m_stripes, and Kwave::Stripe::start().

{
    qDebug("------------------------------------");
    unsigned int   index    = 0;
    sample_index_t last_end = 0;
    foreach (const Stripe &s, m_stripes) {
        sample_index_t start = s.start();
        if (index && (start <= last_end))
            qDebug("--- OVERLAP ---");
        if (start > last_end+1)
            qDebug("       : GAP         [%10lu - %10lu] (%10lu)",
            static_cast<unsigned long int>(last_end + ((index) ? 1 : 0)),
            static_cast<unsigned long int>(start - 1),
            static_cast<unsigned long int>(start - last_end -
                ((index) ? 1 : 0)));
        qDebug("#%6d: %p - [%10lu - %10lu] (%10lu)",
               index++, static_cast<const void *>(&s),
               static_cast<unsigned long int>(s.start()),
               static_cast<unsigned long int>(s.end()),
               static_cast<unsigned long int>(s.length()));
        last_end = s.end();
    }
    qDebug("------------------------------------");
}

Here is the call graph for this function:

insertSpace()

bool Kwave::Track::insertSpace	(	sample_index_t	offset,
		sample_index_t	shift
	)

Inserts space at a given offset by moving all stripes that are are starting at or after the given offset right.

Parameters

offset	position after which everything is moved right
shift	distance of the shift [samples]

Returns

true if succeeded, false if failed (OOM?)

Definition at line 314 of file Track.cpp.

References Kwave::Stripe::end(), Kwave::Stripe::length(), m_lock, m_stripes, moveRight(), Kwave::Stripe::resize(), sigSamplesInserted(), splitStripe(), Kwave::Stripe::start(), Kwave::toUint(), and unlockedLength().

Referenced by Kwave::Signal::insertSpace().

{
//     qDebug("Kwave::Track::insertSpace(offset=%u,shift=%u)",offset, shift);
    if (!shift) return true;

    {
        QMutexLocker lock(&m_lock);
        sample_index_t len = unlockedLength();
        if (offset < len) {
            // find out whether the offset is within a stripe and
            // split that one if necessary
            QMutableListIterator<Stripe> it(m_stripes);
            while (it.hasNext()) {
                Stripe &s = it.next();
                sample_index_t end    = s.end();
                if (end < offset) continue; // skip, stripe is at left

                sample_index_t start  = s.start();
                if (start >= offset) break; // not "within" the stripe

//              qDebug("Kwave::Track::insertSpace => splitting [%u...%u]",start,end);
                Stripe new_stripe = splitStripe(s,
                    Kwave::toUint(offset - start)
                );
                if (!new_stripe.length()) return false; // OOM ?
                it.insert(new_stripe);
                break;
            }

            // move all stripes that are after the offset right
//          qDebug("Kwave::Track::insertSpace => moving right");
            moveRight(offset, shift);
        } else {
//          qDebug("Kwave::Track::insertSpace => appending stripe at %u", offset + shift - 1);
            Stripe s(offset + shift - 1);
            s.resize(1);
            if (s.length()) m_stripes.append(s);
        }
    }

//     dump();
    emit sigSamplesInserted(this, offset, shift);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

length()

sample_index_t Kwave::Track::length

(

)

Returns the length of the track. This is equivalent to the position of the last sample of the last Stripe.

Definition at line 173 of file Track.cpp.

References m_lock, and unlockedLength().

Referenced by appendAfter(), Kwave::Signal::length(), Kwave::SignalManager::loadFile(), openReader(), Kwave::TrackPixmap::repaint(), unlockedDelete(), and Kwave::TrackPixmap::validateBuffer().

{
    QMutexLocker lock(&m_lock);
    return unlockedLength();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mergeStripe()

bool Kwave::Track::mergeStripe ( Kwave::Stripe &  stripe )

private

Merge a single stripe into the track.

Parameters

stripe

the stripe to merge

Returns

true if succeeded, false if failed

Definition at line 133 of file Track.cpp.

References Kwave::Stripe::end(), m_stripes, Kwave::Stripe::start(), and unlockedDelete().

Referenced by mergeStripes().

{
    sample_index_t left  = stripe.start();
    sample_index_t right = stripe.end();
    int index_before = -1;

//     qDebug("Track::mergeStripe() [%llu - %llu]", left, right);
//     dump();

    // remove all stripes that are overlapped completely by
    // this stripe and crop stripes that overlap partially
    unlockedDelete(left, right - left + 1, true);

//     qDebug("Track::mergeStripe() [%llu - %llu] - after delete", left, right);
//     dump();

    // find the stripe after which we have to insert
    QListIterator<Stripe> it(m_stripes);
    while (it.hasNext()) {
        const Stripe &s = it.next();
        if (left > s.end()) index_before = m_stripes.indexOf(s);
    }

    if (index_before >= 0) {
        // insert after some existing stripe
//      qDebug("Kwave::Track::mergeStripe: insert after index %d",
//             index_before);
        m_stripes.insert(index_before + 1, stripe);
    } else {
        // the one and only or insert before all others
//      qDebug("Kwave::Track::mergeStripe: prepending");
        m_stripes.prepend(stripe);
    }

//     qDebug("Track::mergeStripe() - done");
//     dump();
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mergeStripes()

bool Kwave::Track::mergeStripes

(

const Kwave::Stripe::List &

stripes

)

Merge a list of stripes into the track.

Parameters

stripes

list of stripes

Returns

true if succeeded, false if failed

Note

triggers a defragmentation

Definition at line 251 of file Track.cpp.

References defragment(), Kwave::Stripe::List::left(), m_lock, mergeStripe(), Kwave::Stripe::List::right(), and sigSamplesModified().

Referenced by Kwave::Signal::mergeStripes().

{
    bool succeeded = true;
    {
        QMutexLocker lock(&m_lock);
        foreach (Stripe stripe, stripes) {
            if (!mergeStripe(stripe)) {
                succeeded = false;
                break;
            }
        }
    }

    // do some defragmentation, to combine the ends of the inserted stripes
    defragment();

    const sample_index_t left  = stripes.left();
    const sample_index_t right = stripes.right();
    emit sigSamplesModified(this, left, right - left + 1);
    return succeeded;
}

Here is the call graph for this function:

Here is the caller graph for this function:

moveRight()

void Kwave::Track::moveRight ( sample_index_t  offset, sample_index_t  shift  )

private

Move all stripes after an offset to the right. Only looks at the start position of the stripes, comparing with ">=", if the start of a stripe is at the given offset, it will not be moved!

Parameters

offset	position after which everything is moved right
shift	distance of the shift [samples]

Definition at line 546 of file Track.cpp.

References m_stripes, Kwave::Stripe::setStart(), and Kwave::Stripe::start().

Referenced by insertSpace(), and writeSamples().

{
    if (m_stripes.isEmpty()) return;
    QMutableListIterator<Stripe> it(m_stripes);
    it.toBack();
    while (it.hasPrevious()) {
        Stripe &s = it.previous();
        sample_index_t start = s.start();
        if (start < offset) break;

        s.setStart(start + shift);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

newStripe()

Stripe* Kwave::Track::newStripe ( sample_index_t  start, unsigned int  length  )

private

Creates a new stripe with a start position and a length.

Parameters

start	offset of the first sample
length	number of samples, zero is allowed

Note

this must be private, it does no locking !

openReader()

Kwave::SampleReader * Kwave::Track::openReader	(	Kwave::ReaderMode	mode,
		sample_index_t	left = 0,
		sample_index_t	right = SAMPLE_INDEX_MAX
	)

Opens a stream for reading samples. If the last position is omitted, the value UINT_MAX will be used.

Parameters

mode	read mode, see Kwave::ReaderMode
left	first offset to be read (default = 0)
right	last position to read (default = UINT_MAX)

Definition at line 274 of file Track.cpp.

References length(), m_lock, stripes(), and unlockedLength().

Referenced by Kwave::Signal::openReader(), and Kwave::TrackPixmap::validateBuffer().

{
    QMutexLocker lock(&m_lock);

    const sample_index_t length = unlockedLength();
    if (right >= length) right = (length) ? (length - 1) : 0;

    // collect all stripes that are in the requested range
    Kwave::Stripe::List stripe_list = stripes(left, right);

    // create the input stream
    Kwave::SampleReader *stream =
        new(std::nothrow) Kwave::SampleReader(mode, stripe_list);
    Q_ASSERT(stream);
    return stream;
}

Here is the call graph for this function:

Here is the caller graph for this function:

openWriter()

Kwave::Writer * Kwave::Track::openWriter	(	Kwave::InsertMode	mode,
		sample_index_t	left = 0,
		sample_index_t	right = 0
	)

Opens a stream for writing samples, starting at a sample position.

Parameters

mode	specifies where and how to insert
left	start of the input (only useful in insert and overwrite mode)
right	end of the input (only useful with overwrite mode)

See also

InsertMode

Note

destruction of the writer triggers defragmentation

Definition at line 188 of file Track.cpp.

References Kwave::connect(), and defragment().

Referenced by Kwave::Signal::openWriter().

{
    // create the input stream
    Kwave::Writer *stream =
        new(std::nothrow) Kwave::TrackWriter(*this, mode, left, right);
    Q_ASSERT(stream);

    if (stream) {
        // at the point of time when the writer gets closed we can take
        // care of fragmentation
        connect(stream, SIGNAL(destroyed(QObject*)),
                this,   SLOT(defragment()),
                Qt::DirectConnection);
    }

    return stream;
}

Here is the call graph for this function:

Here is the caller graph for this function:

release()

void Kwave::Track::release ( )

protected

decrements the usage counter (read lock to m_lock_usage)

Definition at line 769 of file Track.cpp.

References m_lock_usage.

Referenced by Kwave::TrackWriter::~TrackWriter().

{
    m_lock_usage.unlock();
}

Here is the caller graph for this function:

select()

void Kwave::Track::select

(

bool

select

)

Sets the "selected" flag.

Definition at line 464 of file Track.cpp.

References m_selected, selected(), and sigSelectionChanged().

Referenced by toggleSelection().

{
    if (m_selected == selected) return;
    m_selected = selected;
    emit sigSelectionChanged(m_selected);
}

Here is the call graph for this function:

Here is the caller graph for this function:

selected()

bool Kwave::Track::selected ( ) const

inline

Returns the "selected" flag.

Definition at line 137 of file Track.h.

Referenced by Kwave::TrackPixmap::repaint(), select(), toggleSelection(), and Kwave::TrackView::TrackView().

{ return m_selected; }

Here is the caller graph for this function:

sigSamplesDeleted

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

signal

Emitted if data has been removed from the track.

Parameters

src	source track of the signal (*this)
offset	position from which the data was removed
length	number of samples deleted

Referenced by deleteRange().

Here is the caller graph for this function:

sigSamplesInserted

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

signal

Emitted if the track has grown. This implies a modification of the inserted data, so no extra sigSamplesModified is emitted.

Parameters

src	source track of the signal (*this)
offset	position from which the data was inserted
length	number of samples inserted

See also

sigSamplesModified

Referenced by appendStripe(), insertSpace(), and writeSamples().

Here is the caller graph for this function:

sigSamplesModified

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

signal

Emitted if some data within the track has been modified.

Parameters

src	source track of the signal (*this)
offset	position from which the data was modified
length	number of samples modified

Referenced by mergeStripes(), and writeSamples().

Here is the caller graph for this function:

sigSelectionChanged

void Kwave::Track::sigSelectionChanged ( bool  selected )

signal

Emitted whenever the selection of the track has changed.

Parameters

selected

true if selected, false if unselected

Referenced by select().

Here is the caller graph for this function:

splitStripe()

Kwave::Stripe Kwave::Track::splitStripe ( Kwave::Stripe &  stripe, unsigned int  offset  )

private

Split a stripe into two stripes. The new stripe will be created from the right portion of the given stripe and the original stripe will be shrinked to it's new size. The newly created stripe will be inserted into m_stripes after the old one.

Parameters

stripe	the stripe to be split
offset	the offset within the stripe, which becomes the first sample in the new stripe

Returns

the new created stripe

Definition at line 111 of file Track.cpp.

References Kwave::Stripe::length(), Kwave::Stripe::resize(), and Kwave::Stripe::start().

Referenced by insertSpace(), unlockedDelete(), and writeSamples().

{
    Q_ASSERT(offset < stripe.length());
    Q_ASSERT(offset);
    if (offset >= stripe.length()) return Stripe();
    if (!offset) return 0;

    // create a new stripe with the data that has been split off
    Stripe s(stripe.start() + offset, stripe, offset);
    if (!s.length()) return Stripe();

    // shrink the old stripe
    stripe.resize(offset);

//     qDebug("Kwave::Track::splitStripe(%p, %u): new stripe at [%u ... %u] (%u)",
//            stripe, offset, s->start(), s->end(), s->length());

    return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

stripes()

Kwave::Stripe::List Kwave::Track::stripes	(	sample_index_t	left,
		sample_index_t	right
	)

Get a list of stripes that matches a given range of samples

Parameters

left	offset of the first sample
right	offset of the last sample

Returns

a list of stripes that cover the given range between left and right

Definition at line 209 of file Track.cpp.

References Kwave::Stripe::deleteRange(), Kwave::Stripe::end(), Kwave::Stripe::length(), m_lock, m_stripes, Kwave::Stripe::resize(), Kwave::Stripe::setStart(), Kwave::Stripe::start(), and Kwave::toUint().

Referenced by openReader(), and Kwave::Signal::stripes().

{
    QMutexLocker lock(&m_lock);

    // collect all stripes that are in the requested range
    Kwave::Stripe::List stripes(left, right);
    foreach (const Stripe &stripe, m_stripes) {
        if (!stripe.length()) continue;
        sample_index_t start = stripe.start();
        sample_index_t end   = stripe.end();

        if (end < left) continue; // not yet in range
        if (start > right) break; // done

        if ((end <= right) && (start >= left)) {
            // append the stripe as it is, unmodified
            stripes.append(stripe);
            continue;
        }

        // there is only some overlap, no 100% match
        // -> make a cropped copy
        Stripe cropped(stripe);

        // remove data after the end of the selection
        if (end > right)
            cropped.resize(Kwave::toUint(cropped.length() - (end - right)));

        // remove data before the start of the selection
        if (start < left) {
            cropped.deleteRange(0, Kwave::toUint(left - start));
            cropped.setStart(left);
        }

        stripes.append(cropped);
    }

    return stripes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

toggleSelection

void Kwave::Track::toggleSelection ( )

slot

toggles the selection of the slot on/off

Definition at line 472 of file Track.cpp.

References select(), and selected().

{
    select(!selected());
}

Here is the call graph for this function:

unlockedDelete()

void Kwave::Track::unlockedDelete ( sample_index_t  offset, sample_index_t  length, bool  make_gap = false  )

private

Deletes a range of samples, used internally by deleteRange()

Parameters

offset	index of the first sample
length	number of samples
make_gap	if true, make a gap into the list of stripes instead of moving the stuff from right to left

Definition at line 360 of file Track.cpp.

References Kwave::Stripe::deleteRange(), Kwave::Stripe::end(), length(), Kwave::Stripe::length(), m_stripes, Kwave::Stripe::setStart(), splitStripe(), Kwave::Stripe::start(), and Kwave::toUint().

Referenced by deleteRange(), mergeStripe(), and writeSamples().

{
    if (!length) return;

    // add all stripes within the specified range to the list
    sample_index_t left  = offset;
    sample_index_t right = offset + length - 1;

    QMutableListIterator<Stripe> it(m_stripes);
    it.toBack();
    while (it.hasPrevious()) {
        Stripe &s = it.previous();
        sample_index_t start  = s.start();
        sample_index_t end    = s.end();

        if (end   < left)  break;    // done, stripe is at left
        if (start > right) continue; // skip, stripe is at right

        if ((left <= start) && (right >= end)) {
            // case #1: total overlap -> delete whole stripe
//          qDebug("deleting stripe [%u ... %u]", start, end);
            it.remove(); // decrements the iterator !!!
            if (m_stripes.isEmpty()) break;
            continue;
        } else /* if ((end >= left) && (start <= right)) */ {
            //        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            //        already checked above
            // partial stripe overlap
            sample_index_t ofs = (start < left) ? left : start;
            if (end > right) end = right;
//          qDebug("deleting [%u ... %u] (start=%u, ofs-start=%u, len=%u)",
//              ofs, end, start, ofs-start, end - ofs + 1);

            if (!make_gap ||
                ((left <= s.start()) && (right  < s.end())) ||
                ((left  > s.start()) && (right >= s.end())))
            {
                // case #2: delete without creating a gap
                // case #3: delete from the left only
                // case #4: delete from the right only
//              qDebug("    deleting within the stripe");
                s.deleteRange(
                    Kwave::toUint(ofs - start),
                    Kwave::toUint(end - ofs + 1)
                );
                if (!s.length()) break; // OOM ?

                // if deleted from start
                if (left <= s.start()) {
                    // move right, producing a (temporary) gap
//                  qDebug("shifting [%u ... %u] to %u",
//                          start, s.end(), end + 1);
                    s.setStart(end + 1);
                }
            } else {
                // case #5: delete from the middle and produce a gap
                //          by splitting off a new stripe
//              qDebug("    splitting off to new stripe @ %u (ofs=%u)",
//                  right + 1, right + 1 - start);
                Stripe new_stripe = splitStripe(s,
                    Kwave::toUint(right + 1 - start));
                if (!new_stripe.length()) break; // OOM ?
                it.next(); // right after "s"
                it.insert(new_stripe);
                it.previous(); // before new_stripe == after s
                it.previous(); // before s, like

                // erase to the end (reduce size)
                const unsigned int todel = Kwave::toUint(s.end() - ofs + 1);
//              qDebug("ofs-start=%u, s->end()-ofs+1=%u [%u...%u] (%u)",
//                  ofs-start, todel, s.start(), s.end(), s.length());
                s.deleteRange(Kwave::toUint(ofs - start), todel);
//              qDebug("length now: %u [%u ... %u]", s.length(),
//                  s.start(), s.end());
//              Q_ASSERT(s.length());
            }
//          Q_ASSERT(s.length());
        }
    }

    // loop over all remaining stripes and move them left
    // (maybe we start the search one stripe too left,
    // but this doesn't matter, we don't care...)
    if (!make_gap) {
        if (!it.hasNext()) it.toFront();

        while (it.hasNext()) {
            Stripe &s = it.next();
//          qDebug("checking for shift [%u ... %u]",
//                  s.start(), s.end());
            Q_ASSERT(s.start() != right);
            if (s.start() > right) {
                // move left
//              qDebug("moving stripe %p [%u...%u] %u samples left",
//                      s, s.start(), s.end(), length);
                Q_ASSERT(s.start() >= length);
                s.setStart(s.start() - length);
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

unlockedLength()

sample_index_t Kwave::Track::unlockedLength ( )

private

Returns the current length of the stripe in samples. This function uses no locks and is therefore reserved for internal usage from within locked functions.

Note

this must be private, it does no locking !

Definition at line 180 of file Track.cpp.

References Kwave::Stripe::length(), m_stripes, and Kwave::Stripe::start().

Referenced by appendStripe(), insertSpace(), length(), and openReader().

{
    if (m_stripes.isEmpty()) return 0;
    const Stripe &s = m_stripes.last();
    return s.start() + s.length();
}

Here is the call graph for this function:

Here is the caller graph for this function:

use()

void Kwave::Track::use ( )

protected

increments the usage counter (read lock to m_lock_usage)

Definition at line 763 of file Track.cpp.

References m_lock_usage.

Referenced by Kwave::TrackWriter::TrackWriter().

{
    m_lock_usage.lockForRead();
}

Here is the caller graph for this function:

uuid()

const QUuid& Kwave::Track::uuid ( ) const

inline

returns the unique ID of this track instance

Definition at line 143 of file Track.h.

Referenced by Kwave::SelectionTracker::slotTrackDeleted(), and Kwave::SelectionTracker::slotTrackInserted().

{ return m_uuid; }

Here is the caller graph for this function:

writeSamples()

bool Kwave::Track::writeSamples ( Kwave::InsertMode  mode, sample_index_t  offset, const Kwave::SampleArray &  buffer, unsigned int  buf_offset, unsigned int  length  )

protected

Write a block of samples. If necessary it starts, appends to, or splits a stripe.

Parameters

mode	a InsertMode (append/overwrite/insert)
offset	position where to start the write operation
buffer	array with samples
buf_offset	offset within the buffer
length	number of samples to write

Returns

true if successful, false if failed (e.g. out of memory)

Definition at line 561 of file Track.cpp.

References Kwave::Append, appendAfter(), Kwave::Stripe::end(), Kwave::Insert, Kwave::Stripe::length(), m_lock, m_stripes, moveRight(), Kwave::Overwrite, sigSamplesInserted(), sigSamplesModified(), splitStripe(), Kwave::Stripe::start(), Kwave::toUint(), and unlockedDelete().

Referenced by Kwave::TrackWriter::write().

{
    Q_ASSERT(length);
    if (!length) return true; // nothing to do !?

    switch (mode) {
        case Kwave::Append: {
//          qDebug("writeSamples() - Append");
            bool appended;
            {
                QMutexLocker _lock(&m_lock);
                appended = appendAfter(
                    m_stripes.isEmpty() ? Q_NULLPTR : &(m_stripes.last()),
                    offset, buffer,
                    buf_offset, length);
            }
            if (appended)
                emit sigSamplesInserted(this, offset, length);
            else
                return false; /* out of memory */
            break;
        }
        case Kwave::Insert: {
            m_lock.lock();

//          qDebug("Kwave::Track::writeSamples() - Insert @ %u, length=%u",
//                 offset, length);

            // find the stripe into which we insert
            Stripe *target_stripe = Q_NULLPTR;
            Stripe *stripe_before = Q_NULLPTR;
            QMutableListIterator<Stripe> it(m_stripes);
            while (it.hasNext()) {
                Stripe &s = it.next();
                sample_index_t st  = s.start();
                sample_index_t len = s.length();
                if (!len) continue; // skip zero-length tracks

                if (offset >= st + len) stripe_before = &s;

                if ((offset >= st) && (offset < st+len)) {
                    // match found
                    target_stripe = &s;
                    break;
                }
            }

//          qDebug("stripe_before = %p [%u...%u]", stripe_before,
//                 stripe_before ? stripe_before->start() : 0,
//                 stripe_before ? (stripe_before->start() +
//                                 stripe_before->length() - 1) : 0);
//          qDebug("target_stripe = %p [%u...%u]", target_stripe,
//                 target_stripe ? target_stripe->start() : 0,
//                 target_stripe ? (target_stripe->start() +
//                                 target_stripe->length() - 1) : 0);

            // if insert is requested immediately after the last
            // sample of the stripe before
            if (stripe_before && (offset == stripe_before->start()+
                                  stripe_before->length()))
            {
                // append to the existing stripe
                moveRight(offset, length);
                appendAfter(stripe_before, offset, buffer,
                            buf_offset, length);
                m_lock.unlock();
                emit sigSamplesInserted(this, offset, length);
                break;
            }

            // if no stripe was found, create a new one and
            // insert it between the existing ones
            if (!target_stripe || (offset == target_stripe->start())) {
                // insert somewhere before, between or after stripes
                moveRight(offset, length);
                appendAfter(stripe_before, offset, buffer,
                            buf_offset, length);
            } else {
                // split the target stripe and insert the samples
                // between the two new ones
                Stripe new_stripe = splitStripe(*target_stripe,
                    Kwave::toUint(offset - target_stripe->start())
                );
                if (!new_stripe.length()) {
                    m_lock.unlock();
                    break;
                }
                m_stripes.insert(m_stripes.indexOf(*target_stripe) + 1,
                    new_stripe);

                moveRight(offset, length);
                appendAfter(target_stripe, offset, buffer,
                            buf_offset, length);
            }

            m_lock.unlock();
            emit sigSamplesInserted(this, offset, length);

            break;
        }
        case Kwave::Overwrite: {
//          const sample_index_t left  = offset;
//          const sample_index_t right = offset + length - 1;
//          qDebug("writeSamples() - Overwrite [%u - %u]", left, right);

            {
                QMutexLocker _lock(&m_lock);

                // delete old content, producing a gap
                unlockedDelete(offset, length, true);

                // fill in the content of the buffer, append to the stripe
                // before the gap if possible
                Stripe *stripe_before = Q_NULLPTR;
                QMutableListIterator<Stripe> it(m_stripes);
                while (it.hasNext()) {
                    Stripe &s = it.next();
                    if (s.start() >= offset) break;
                    if (s.end() < offset) stripe_before = &s;
                }
                appendAfter(stripe_before, offset, buffer, buf_offset, length);
            }
            emit sigSamplesModified(this, offset, length);
            break;
        }
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

Kwave::TrackWriter

friend class Kwave::TrackWriter

friend

Definition at line 271 of file Track.h.

Member Data Documentation

m_lock

QMutex Kwave::Track::m_lock

private

lock for access to the whole track

Definition at line 308 of file Track.h.

Referenced by defragment(), deleteRange(), insertSpace(), length(), mergeStripes(), openReader(), stripes(), writeSamples(), and ~Track().

m_lock_usage

QReadWriteLock Kwave::Track::m_lock_usage

private

lock to protect against deletion while the track is in use

Definition at line 311 of file Track.h.

Referenced by release(), use(), and ~Track().

m_selected

bool Kwave::Track::m_selected

private

True if the track is selected

Definition at line 317 of file Track.h.

Referenced by select().

m_stripes

QList<Stripe> Kwave::Track::m_stripes

private

list of stripes (a track actually is a container for stripes)

Definition at line 314 of file Track.h.

Referenced by appendAfter(), appendStripe(), defragment(), dump(), insertSpace(), mergeStripe(), moveRight(), stripes(), Track(), unlockedDelete(), unlockedLength(), writeSamples(), and ~Track().

m_uuid

QUuid Kwave::Track::m_uuid

private

unique ID

Definition at line 320 of file Track.h.

---

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

• libkwave/Track.h
• libkwave/Track.cpp