Kwave::RecordThread Class Reference

#include <RecordThread.h>

Inheritance diagram for Kwave::RecordThread:

Collaboration diagram for Kwave::RecordThread:

Signals
void	bufferFull ()
void	stopped (int errorcode)

Public Member Functions
	RecordThread ()
virtual	~RecordThread () Q_DECL_OVERRIDE
virtual void	run () Q_DECL_OVERRIDE
void	setRecordDevice (Kwave::RecordDevice *device)
int	setBuffers (unsigned int count, unsigned int size)
unsigned int	remainingBuffers ()
unsigned int	queuedBuffers ()
QByteArray	dequeue ()
Public Member Functions inherited from Kwave::WorkerThread
	WorkerThread (Kwave::Runnable *runnable, QVariant params)
virtual	~WorkerThread () Q_DECL_OVERRIDE
virtual void	start ()
virtual int	stop (unsigned int timeout=10000)
virtual void	cancel ()
bool	shouldStop ()

Private Attributes
Kwave::RecordDevice *	m_device
QQueue< QByteArray >	m_empty_queue
QQueue< QByteArray >	m_full_queue
unsigned int	m_buffer_count
unsigned int	m_buffer_size

Detailed Description

Definition at line 33 of file RecordThread.h.

Constructor & Destructor Documentation

RecordThread()

Kwave::RecordThread::RecordThread

(

)

Constructor

Definition at line 28 of file RecordThread.cpp.

    :Kwave::WorkerThread(Q_NULLPTR, QVariant()), m_device(Q_NULLPTR),
    m_empty_queue(), m_buffer_count(0), m_buffer_size(0)
{
}

~RecordThread()

Kwave::RecordThread::~RecordThread ( )

virtual

Destructor

Definition at line 35 of file RecordThread.cpp.

References m_empty_queue, m_full_queue, and Kwave::WorkerThread::stop().

{
    stop();
    m_full_queue.clear();
    m_empty_queue.clear();
}

Here is the call graph for this function:

Member Function Documentation

bufferFull

void Kwave::RecordThread::bufferFull ( )

signal

emitted when a buffer was full and has been de-queued with dequeue()

Referenced by run().

Here is the caller graph for this function:

dequeue()

QByteArray Kwave::RecordThread::dequeue

(

)

De-queues a buffer from the m_full_queue.

Definition at line 87 of file RecordThread.cpp.

References m_empty_queue, and m_full_queue.

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

{
    if (m_full_queue.count()) {
        // de-queue the buffer from the full list
        QByteArray buf = m_full_queue.dequeue();

        // put the buffer back to the empty list
        m_empty_queue.enqueue(buf);

        // return the buffer
        return buf;
    } else {
        // return an empty buffer
        return QByteArray();
    }
}

Here is the caller graph for this function:

queuedBuffers()

unsigned int Kwave::RecordThread::queuedBuffers

(

)

Returns the number of queued filled buffers

Definition at line 81 of file RecordThread.cpp.

References m_full_queue.

Referenced by Kwave::RecordPlugin::enterInhibit(), Kwave::RecordPlugin::processBuffer(), Kwave::RecordPlugin::setup(), and Kwave::RecordPlugin::updateBufferProgressBar().

{
    return (m_full_queue.count());
}

Here is the caller graph for this function:

remainingBuffers()

unsigned int Kwave::RecordThread::remainingBuffers

(

)

Returns the amount of remaining empty buffers

Definition at line 75 of file RecordThread.cpp.

References m_empty_queue.

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

{
    return (m_empty_queue.count());
}

Here is the caller graph for this function:

run()

void Kwave::RecordThread::run ( )

virtual

does the recording

Reimplemented from Kwave::WorkerThread.

Definition at line 105 of file RecordThread.cpp.

References bufferFull(), m_device, m_empty_queue, m_full_queue, Kwave::RecordDevice::read(), Kwave::WorkerThread::shouldStop(), and stopped().

{
    int result = 0;
    bool interrupted = false;

    // read data until we receive a close signal
    while (!shouldStop() && !interrupted) {
        // dequeue a buffer from the "empty" queue

        if (m_empty_queue.isEmpty()) {
            // we had a "buffer overflow"
            qWarning("RecordThread::run() -> NO EMPTY BUFFER FOUND !!!");
            result = -ENOBUFS;
            break;
        }

        QByteArray buffer = m_empty_queue.dequeue();
        int len = buffer.size();
        Q_ASSERT(buffer.size());
        if (!len) {
            result = -ENOBUFS;
            break;
        }

        // read into the current buffer
        unsigned int offset = 0;
        while (len && !interrupted && !shouldStop()) {
            // read raw data from the record device
            result =  (m_device) ?
                m_device->read(buffer, offset) : -EBADF;

            if ((result < 0) && (result != -EAGAIN))
                qWarning("RecordThread: read result = %d (%s)",
                         result, strerror(-result));

            if (result == -EAGAIN) {
                continue;
            } else if (result == -EBADF) {
                // file open has failed
                interrupted = true;
                break;
            } else if (result == -EINTR) {
                // thread was interrupted, received signal?
                interrupted = true;
                break;
            } else if (result < 1) {
                // something went wrong !?
                interrupted = true;
                qWarning("RecordThread::run(): read returned %d", result);
                break;
            } else {
                offset += result;
                len = buffer.size() - offset;
                Q_ASSERT(len >= 0);
                if (len < 0) len = 0;
            }
        }

        // return buffer into the empty queue and abort on errors
        // do not use it
        if (interrupted && (result < 0)) {
            m_empty_queue.enqueue(buffer);
            break;
        }

        // inform the application that there is something to dequeue
        m_full_queue.enqueue(buffer);
        emit bufferFull();
    }

    // do not evaluate the result of the last operation if there
    // was the external request to stop
    if (shouldStop() || (interrupted && (result > 0)))
        result = 0;

    if (result) emit stopped(result);
}

Here is the call graph for this function:

setBuffers()

int Kwave::RecordThread::setBuffers	(	unsigned int	count,
		unsigned int	size
	)

Set the number of buffers and their size

Parameters

count	the number of buffer, minimum allowed is two
size	the number of bytes for each buffer

Returns

number of allocated buffers or -ENOMEM if less than two

Note

this must not be called during recording

Definition at line 52 of file RecordThread.cpp.

References m_buffer_count, m_buffer_size, m_empty_queue, and m_full_queue.

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

{
    Q_ASSERT(!isRunning());
    if (isRunning()) return -EBUSY;

    // flush all queues
    m_full_queue.clear();
    m_empty_queue.clear();

    // fill the "empty" queue again
    QByteArray buf(size, 0x00);
    for (unsigned int i = 0; i < count; i++)
        m_empty_queue.enqueue(buf);

    // take the new settings
    m_buffer_size  = size;
    m_buffer_count = count;

    // return number of buffers or -ENOMEM if not even two allocated
    return (m_empty_queue.count() >= 2) ? m_empty_queue.count() : -ENOMEM;
}

Here is the caller graph for this function:

setRecordDevice()

void Kwave::RecordThread::setRecordDevice

(

Kwave::RecordDevice *

device

)

Select a new record device.

Parameters

device

a RecordDevice that is opened and set up for reading

Note

this must not be called during recording

Definition at line 43 of file RecordThread.cpp.

References m_device.

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

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

    m_device = device;
}

Here is the caller graph for this function:

stopped

void Kwave::RecordThread::stopped ( int  errorcode )

signal

emitted when the recording stops or aborts

Parameters

errorcode

zero if stopped normally or a negative error code if aborted

Referenced by run().

Here is the caller graph for this function:

Member Data Documentation

m_buffer_count

unsigned int Kwave::RecordThread::m_buffer_count

private

number of buffers to allocate

Definition at line 99 of file RecordThread.h.

Referenced by setBuffers().

m_buffer_size

unsigned int Kwave::RecordThread::m_buffer_size

private

size of m_buffer in bytes

Definition at line 102 of file RecordThread.h.

Referenced by setBuffers().

m_device

Kwave::RecordDevice* Kwave::RecordThread::m_device

private

the device used as source

Definition at line 90 of file RecordThread.h.

Referenced by run(), and setRecordDevice().

m_empty_queue

QQueue<QByteArray> Kwave::RecordThread::m_empty_queue

private

queue with empty buffers for raw input data

Definition at line 93 of file RecordThread.h.

Referenced by dequeue(), remainingBuffers(), run(), setBuffers(), and ~RecordThread().

m_full_queue

QQueue<QByteArray> Kwave::RecordThread::m_full_queue

private

queue with filled buffers with raw input data

Definition at line 96 of file RecordThread.h.

Referenced by dequeue(), queuedBuffers(), run(), setBuffers(), and ~RecordThread().

---

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

• plugins/record/RecordThread.h
• plugins/record/RecordThread.cpp