Kwave::SampleFIFO Class Reference

#include <SampleFIFO.h>

Collaboration diagram for Kwave::SampleFIFO:

Public Member Functions
	SampleFIFO ()
	SampleFIFO (const SampleFIFO &other)
virtual	~SampleFIFO ()
virtual void	flush ()
virtual void	put (const Kwave::SampleArray &source)
virtual unsigned int	get (Kwave::SampleArray &buffer)
virtual unsigned int	length ()
virtual void	setSize (unsigned int size)
virtual void	crop ()

Private Member Functions
unsigned int	unlockedLength ()

Private Attributes
QQueue< Kwave::SampleArray >	m_buffer
sample_index_t	m_size
sample_index_t	m_read_offset
QMutex	m_lock

Detailed Description

Definition at line 32 of file SampleFIFO.h.

Constructor & Destructor Documentation

SampleFIFO() [1/2]

Kwave::SampleFIFO::SampleFIFO

(

)

Constructor

Definition at line 24 of file SampleFIFO.cpp.

    :m_buffer(), m_size(0), m_read_offset(0), m_lock(QMutex::Recursive)
{
}

SampleFIFO() [2/2]

Kwave::SampleFIFO::SampleFIFO

(

const SampleFIFO &

other

)

copy constructor

Definition at line 30 of file SampleFIFO.cpp.

    :m_buffer(other.m_buffer), m_size(other.m_size),
     m_read_offset(other.m_read_offset),
     m_lock(QMutex::Recursive)
{
}

~SampleFIFO()

Kwave::SampleFIFO::~SampleFIFO ( )

virtual

Destructor

Definition at line 38 of file SampleFIFO.cpp.

References flush(), and m_lock.

{
    QMutexLocker _lock(&m_lock);
    flush();
}

Here is the call graph for this function:

Member Function Documentation

crop()

void Kwave::SampleFIFO::crop ( )

virtual

discards all superfluous content until the size condition is met.

Definition at line 136 of file SampleFIFO.cpp.

References m_buffer, m_lock, m_read_offset, m_size, and unlockedLength().

Referenced by Kwave::RecordPlugin::flushPrerecordingQueue().

{
    QMutexLocker _lock(&m_lock);

    if (!m_size) return; // no limit set
    if (unlockedLength() <= m_size) return; // nothing to do

    // we have to throw away some samples
    while ((unlockedLength() - m_buffer.head().size()) > m_size)
        m_buffer.dequeue();
    m_read_offset = 0;
    if (unlockedLength() <= m_size) return; // nothing more to do

    // put the read offset into the next buffer
    Q_ASSERT(unlockedLength() > m_size);
    m_read_offset = unlockedLength() - m_size;
    Q_ASSERT(unlockedLength() - m_read_offset == m_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

flush()

void Kwave::SampleFIFO::flush ( )

virtual

Reset the FIFO. This destroys the content and sets all pointers to their initial value.

Definition at line 45 of file SampleFIFO.cpp.

References m_buffer, m_lock, and m_read_offset.

Referenced by Kwave::RecordPlugin::flushPrerecordingQueue(), Kwave::Delay::setDelay(), and ~SampleFIFO().

{
    QMutexLocker _lock(&m_lock);

    m_buffer.clear();
    m_read_offset = 0;
}

Here is the caller graph for this function:

get()

unsigned int Kwave::SampleFIFO::get ( Kwave::SampleArray &  buffer )

virtual

gets and removes samples from the FIFO

Parameters

buffer

reference to an array of samples to be filled

Returns

number of received samples

Definition at line 70 of file SampleFIFO.cpp.

References Kwave::SampleArray::constData(), Kwave::SampleArray::data(), length(), m_buffer, m_lock, m_read_offset, MEMCPY, and Kwave::SampleArray::size().

Referenced by Kwave::RecordPlugin::flushPrerecordingQueue(), and Kwave::Delay::goOn().

{
    QMutexLocker _lock(&m_lock);

    if (m_buffer.isEmpty()) return 0;

    unsigned int rest = buffer.size();
    const unsigned int available = length();
    if (rest > available) rest = available;

    sample_t *dst = buffer.data();
    unsigned int read = 0;
    while (rest && !m_buffer.isEmpty()) {
        const Kwave::SampleArray head = m_buffer.head();
        const sample_t *src     = head.constData();
        unsigned int    src_len = head.size();
        Q_ASSERT(src_len > m_read_offset);

        if (m_read_offset + rest >= src_len) {
            // use the whole buffer up to it's end
            size_t len = static_cast<size_t>(src_len - m_read_offset);
            MEMCPY(dst, src + m_read_offset, len * sizeof(sample_t));
            rest  -= len;
            read  += len;
            dst   += len;
            m_read_offset = 0;

            // remove the buffer from the queue
            m_buffer.dequeue();
        } else {
            // use only a portion of the buffer
            MEMCPY(dst, src + m_read_offset, rest * sizeof(sample_t));
            read          += rest;
            m_read_offset += rest;
            Q_ASSERT(m_read_offset < src_len);
            rest = 0;
        }
    }

    return read;
}

Here is the call graph for this function:

Here is the caller graph for this function:

length()

unsigned int Kwave::SampleFIFO::length ( )

virtual

Returns the number of samples that can be read out.

See also

m_written

Definition at line 122 of file SampleFIFO.cpp.

References m_lock, and unlockedLength().

Referenced by Kwave::RecordPlugin::flushPrerecordingQueue(), and get().

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

Here is the call graph for this function:

Here is the caller graph for this function:

put()

void Kwave::SampleFIFO::put ( const Kwave::SampleArray &  source )

virtual

puts samples into the FIFO

Parameters

source

reference to an array of samples to feed in

Definition at line 54 of file SampleFIFO.cpp.

References Kwave::SampleArray::isEmpty(), m_buffer, m_lock, m_size, and unlockedLength().

Referenced by Kwave::Delay::input(), and Kwave::Delay::setDelay().

{
    if (buffer.isEmpty()) return;
    QMutexLocker _lock(&m_lock);

    // always enqueue the new buffer
    m_buffer.enqueue(buffer);

    if (!m_size) return; // no limit set

    // crop away whole unneeded buffers
    while ((unlockedLength() - m_buffer.head().size()) > m_size)
        m_buffer.dequeue();
}

Here is the call graph for this function:

Here is the caller graph for this function:

setSize()

void Kwave::SampleFIFO::setSize ( unsigned int  size )

virtual

sets the maximum size of the content

Definition at line 129 of file SampleFIFO.cpp.

References m_lock, and m_size.

{
    QMutexLocker _lock(&m_lock);
    m_size = size;
}

unlockedLength()

unsigned int Kwave::SampleFIFO::unlockedLength ( )

private

internal version of length(), without locking

Definition at line 113 of file SampleFIFO.cpp.

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

Referenced by crop(), length(), and put().

{
    unsigned int len = 0;
    foreach (const Kwave::SampleArray &buf, m_buffer)
        len += buf.size();
    return len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_buffer

QQueue<Kwave::SampleArray> Kwave::SampleFIFO::m_buffer

private

list of buffers with sample data

Definition at line 90 of file SampleFIFO.h.

Referenced by crop(), flush(), get(), put(), and unlockedLength().

m_lock

QMutex Kwave::SampleFIFO::m_lock

private

mutex for access to the FIFO (recursive)

Definition at line 102 of file SampleFIFO.h.

Referenced by crop(), flush(), get(), length(), put(), setSize(), and ~SampleFIFO().

m_read_offset

sample_index_t Kwave::SampleFIFO::m_read_offset

private

number of samples that have already been read out from the first buffer (head, first one to read out)

Definition at line 99 of file SampleFIFO.h.

Referenced by crop(), flush(), and get().

m_size

sample_index_t Kwave::SampleFIFO::m_size

private

maximum number of samples of the content

Definition at line 93 of file SampleFIFO.h.

Referenced by crop(), put(), and setSize().

---

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

• libkwave/SampleFIFO.h
• libkwave/SampleFIFO.cpp