Kwave::RecordController Class Reference

#include <RecordController.h>

Inheritance diagram for Kwave::RecordController:

Collaboration diagram for Kwave::RecordController:

Public Slots
void	setInitialized (bool initialized)
void	setEmpty (bool empty)
void	enablePrerecording (bool enable)
void	actionReset ()
void	actionStop ()
void	actionPause ()
void	actionStart ()
void	deviceRecordStarted ()
void	deviceBufferFull ()
void	deviceTriggerReached ()
void	deviceRecordStopped (int)
void	enableTrigger (bool enable)

Signals
void	stateChanged (Kwave::RecordState state)
void	sigReset (bool &accepted)
void	sigStartRecord ()
void	sigStopRecord (int errorcode)

Public Member Functions
	RecordController ()
virtual	~RecordController ()
const char *	stateName (const Kwave::RecordState state)

Private Attributes
Kwave::RecordState	m_state
Kwave::RecordState	m_next_state
bool	m_trigger_set
bool	m_enable_prerecording
bool	m_empty

Detailed Description

Definition at line 29 of file RecordController.h.

Constructor & Destructor Documentation

RecordController()

Kwave::RecordController::RecordController

(

)

Constructor

Definition at line 24 of file RecordController.cpp.

    :QObject(),
     m_state(Kwave::REC_UNINITIALIZED),
     m_next_state(Kwave::REC_EMPTY),
     m_trigger_set(false),
     m_enable_prerecording(false),
     m_empty(true)
{
}

~RecordController()

Kwave::RecordController::~RecordController ( )

virtual

Destructor

Definition at line 35 of file RecordController.cpp.

{
}

Member Function Documentation

actionPause

void Kwave::RecordController::actionPause ( )

slot

Pause the recording

Definition at line 115 of file RecordController.cpp.

References m_state, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, stateChanged(), and stateName().

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
        case Kwave::REC_EMPTY:
        case Kwave::REC_DONE:
            // what do you want ?
            break;
        case Kwave::REC_BUFFERING:
        case Kwave::REC_WAITING_FOR_TRIGGER:
        case Kwave::REC_PRERECORDING:
            // this should never happen
            qWarning("RecordController::actionPause(): "
                     "state = %s ???", stateName(m_state));
            break;
        case Kwave::REC_RECORDING:
            // pause recording
            emit stateChanged(m_state = Kwave::REC_PAUSED);
            break;
        case Kwave::REC_PAUSED:
            // continue recording
            emit stateChanged(m_state = Kwave::REC_RECORDING);
            break;
    }
}

Here is the call graph for this function:

actionReset

void Kwave::RecordController::actionReset ( )

slot

Clear all recorded data and prepare for new recording

Definition at line 64 of file RecordController.cpp.

References m_next_state, m_state, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, sigReset(), and stateChanged().

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
            // already empty, nothing to do
            break;
        case Kwave::REC_RECORDING:
#if 0
            // fall back to REC_WAITING_FOR_TRIGGER
            m_next_state = Kwave::REC_EMPTY;
            emit stateChanged(m_state = Kwave::REC_WAITING_FOR_TRIGGER);
            break;
#endif
        case Kwave::REC_EMPTY:
        case Kwave::REC_BUFFERING:
        case Kwave::REC_WAITING_FOR_TRIGGER:
        case Kwave::REC_PRERECORDING:
        case Kwave::REC_PAUSED:
        case Kwave::REC_DONE:
            bool accepted = true;
            emit sigReset(accepted);
            if (accepted) emit stateChanged(m_state = Kwave::REC_EMPTY);
            break;
    }
}

actionStart

void Kwave::RecordController::actionStart ( )

slot

Start the recording

Definition at line 142 of file RecordController.cpp.

References m_next_state, m_state, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, sigStartRecord(), and stateChanged().

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

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
            break; // impossible
        case Kwave::REC_EMPTY:
        case Kwave::REC_DONE:
            // interpret this as manual trigger
            emit sigStartRecord();
            break;
        case Kwave::REC_BUFFERING:
        case Kwave::REC_PRERECORDING:
        case Kwave::REC_WAITING_FOR_TRIGGER:
            // interpret as "trigger now"
            m_next_state = Kwave::REC_EMPTY;
            emit stateChanged(m_state = Kwave::REC_RECORDING);
            break;
        case Kwave::REC_PAUSED:
            // interpret this as "continue"
            m_next_state = Kwave::REC_RECORDING;
            emit sigStartRecord();
            break;
        case Kwave::REC_RECORDING:
            // already recording...
            m_next_state = Kwave::REC_DONE;
            break;
    }
}

Here is the caller graph for this function:

actionStop

void Kwave::RecordController::actionStop ( )

slot

Stop the recording

Definition at line 91 of file RecordController.cpp.

References m_next_state, m_state, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, and sigStopRecord().

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

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
        case Kwave::REC_EMPTY:
        case Kwave::REC_DONE:
            // already stopped, nothing to do
            break;
        case Kwave::REC_BUFFERING:
        case Kwave::REC_WAITING_FOR_TRIGGER:
        case Kwave::REC_PRERECORDING:
            // abort, change to REC_EMPTY
            emit sigStopRecord(0);
            break;
        case Kwave::REC_RECORDING:
        case Kwave::REC_PAUSED:
            // abort, change to REC_DONE
            m_next_state = Kwave::REC_DONE;
            emit sigStopRecord(0);
            break;
    }
}

Here is the caller graph for this function:

deviceBufferFull

void Kwave::RecordController::deviceBufferFull ( )

slot

The device buffer contains data

Definition at line 196 of file RecordController.cpp.

References m_enable_prerecording, m_next_state, m_state, m_trigger_set, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, stateChanged(), and stateName().

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

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
            break; // impossible
        case Kwave::REC_EMPTY:
            // we are only "recording" for updating the level
            // meters and other effects -> no state change
            break;
        case Kwave::REC_WAITING_FOR_TRIGGER:
        case Kwave::REC_PRERECORDING:
        case Kwave::REC_RECORDING:
            // this should never happen
            qWarning("RecordController::deviceBufferFull(): "
                     "state = %s ???", stateName(m_state));
            break;
        case Kwave::REC_PAUSED: /* == buffering again after pause */
            // -> will change to "REC_BUFFERING" soon...
            break;
        case Kwave::REC_BUFFERING:
            if (m_enable_prerecording) {
                // prerecording was set
                m_state = Kwave::REC_PRERECORDING;
            } else if (m_trigger_set) {
                // trigger was set
                m_state = Kwave::REC_WAITING_FOR_TRIGGER;
            } else {
                // default: just start recording
                m_next_state = Kwave::REC_DONE;
                m_state = Kwave::REC_RECORDING;
            }
            emit stateChanged(m_state);
            break;
        case Kwave::REC_DONE:
            // might occur when the buffer content is flushed
            // after a stop
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

deviceRecordStarted

void Kwave::RecordController::deviceRecordStarted ( )

slot

The device has started recording

Definition at line 172 of file RecordController.cpp.

References m_empty, m_next_state, m_state, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, stateChanged(), and stateName().

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

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
            break; // impossible
        case Kwave::REC_EMPTY:
        case Kwave::REC_PAUSED:
        case Kwave::REC_DONE:
            // continue, pre-recording or trigger
            m_next_state = (m_empty) ? Kwave::REC_EMPTY : Kwave::REC_DONE;
            emit stateChanged(m_state = Kwave::REC_BUFFERING);
            break;
        case Kwave::REC_BUFFERING:
        case Kwave::REC_WAITING_FOR_TRIGGER:
        case Kwave::REC_PRERECORDING:
        case Kwave::REC_RECORDING:
            // this should never happen
            qWarning("RecordController::deviceRecordStarted(): "
                     "state = %s ???", stateName(m_state));
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

deviceRecordStopped

void Kwave::RecordController::deviceRecordStopped ( int  )

slot

The device has stopped recording

Definition at line 275 of file RecordController.cpp.

References m_empty, m_next_state, m_state, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, stateChanged(), and stateName().

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
        case Kwave::REC_EMPTY:
        case Kwave::REC_DONE:
            // this could happen when an abort occurs during buffering
            emit stateChanged(m_state);
            break;
        case Kwave::REC_BUFFERING:
        case Kwave::REC_PRERECORDING:
        case Kwave::REC_WAITING_FOR_TRIGGER:
            // abort, no real data produced
            if (m_empty) {
                emit stateChanged(m_state = Kwave::REC_EMPTY);
            } else {
                emit stateChanged(m_state = Kwave::REC_DONE);
            }
            break;
        case Kwave::REC_RECORDING:
            // recording -> pause or done
            switch (m_next_state) {
                case Kwave::REC_EMPTY:
                    // something went wrong when starting the recorder
                    if (m_empty) {
                        emit stateChanged(m_state = Kwave::REC_EMPTY);
                    } else {
                        emit stateChanged(m_state = Kwave::REC_DONE);
                    }
                    break;
                case Kwave::REC_PAUSED:
                    emit stateChanged(m_state = Kwave::REC_PAUSED);
                    break;
                case Kwave::REC_DONE:
                    emit stateChanged(m_state = Kwave::REC_DONE);
                    break;
                default:
                    qWarning("RecordController::deviceRecordStopped(): "
                             "next state = %s ???", stateName(m_next_state));
            }
            break;
        case Kwave::REC_PAUSED:
            // pause -> done
            emit stateChanged(m_state = Kwave::REC_DONE);
            break;
    }
}

Here is the call graph for this function:

deviceTriggerReached

void Kwave::RecordController::deviceTriggerReached ( )

slot

The record trigger has been reached

Definition at line 243 of file RecordController.cpp.

References m_enable_prerecording, m_next_state, m_state, m_trigger_set, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, stateChanged(), and stateName().

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

{
    switch (m_state) {
        case Kwave::REC_UNINITIALIZED:
        case Kwave::REC_EMPTY:
        case Kwave::REC_BUFFERING:
        case Kwave::REC_RECORDING:
        case Kwave::REC_PAUSED:
        case Kwave::REC_DONE:
            // this should never happen
            qWarning("RecordController::deviceTriggerReached(): "
                     "state = %s ???", stateName(m_state));
            break;
        case Kwave::REC_PRERECORDING:
        case Kwave::REC_WAITING_FOR_TRIGGER:
            Q_ASSERT(m_trigger_set);
            if ((m_enable_prerecording) &&
                (m_state == Kwave::REC_WAITING_FOR_TRIGGER))
            {
                // prerecording was set
                m_state = Kwave::REC_PRERECORDING;
            } else {
                // default: just start recording
                m_state = Kwave::REC_RECORDING;
                m_next_state = Kwave::REC_DONE;
            }
            emit stateChanged(m_state);
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

enablePrerecording

void Kwave::RecordController::enablePrerecording ( bool  enable )

slot

Enable the prerecording. Has to be called before any status change to enable/disable the prerecording mode

Parameters

enable

if true, enable prerecording

Definition at line 58 of file RecordController.cpp.

References m_enable_prerecording.

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

{
    m_enable_prerecording = enable;
}

Here is the caller graph for this function:

enableTrigger

void Kwave::RecordController::enableTrigger ( bool  enable )

slot

The recording trigger has been enabled/disabled

Definition at line 237 of file RecordController.cpp.

References m_trigger_set.

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

{
    m_trigger_set = enable;
}

Here is the caller graph for this function:

setEmpty

void Kwave::RecordController::setEmpty ( bool  empty )

slot

Informs the controller whether the signal is empty or not

Parameters

empty

if true, nothing has been recorded

Definition at line 52 of file RecordController.cpp.

References m_empty.

Referenced by Kwave::RecordPlugin::flushPrerecordingQueue(), Kwave::RecordPlugin::processBuffer(), and Kwave::RecordPlugin::resetRecording().

{
    m_empty = empty;
}

Here is the caller graph for this function:

setInitialized

void Kwave::RecordController::setInitialized ( bool  initialized )

slot

Informs the controller whether the recording engine has been successfully been initialized or recording cannot be started.

Parameters

initialized

if true, recording can be started

Definition at line 40 of file RecordController.cpp.

References m_empty, m_next_state, m_state, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_UNINITIALIZED, and stateChanged().

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

{
    if (initialized) {
        m_next_state = (m_empty) ? Kwave::REC_EMPTY : Kwave::REC_DONE;
        emit stateChanged(m_state = Kwave::REC_EMPTY);
    } else {
        m_next_state = Kwave::REC_UNINITIALIZED;
        emit stateChanged(Kwave::REC_UNINITIALIZED);
    }
}

Here is the caller graph for this function:

sigReset

void Kwave::RecordController::sigReset ( bool &  accepted )

signal

All recorded data has to be cleared

Referenced by actionReset().

Here is the caller graph for this function:

sigStartRecord

void Kwave::RecordController::sigStartRecord ( )

signal

Recording should start

Referenced by actionStart().

Here is the caller graph for this function:

sigStopRecord

void Kwave::RecordController::sigStopRecord ( int  errorcode )

signal

Recording should stop

Referenced by actionStop().

Here is the caller graph for this function:

stateChanged

void Kwave::RecordController::stateChanged ( Kwave::RecordState  state )

signal

emitted when the state of the recording changed

Referenced by actionPause(), actionReset(), actionStart(), deviceBufferFull(), deviceRecordStarted(), deviceRecordStopped(), deviceTriggerReached(), and setInitialized().

Here is the caller graph for this function:

stateName()

const char * Kwave::RecordController::stateName

(

const Kwave::RecordState

state

)

returns the name of a state

Definition at line 324 of file RecordController.cpp.

References Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, and Kwave::REC_WAITING_FOR_TRIGGER.

Referenced by actionPause(), deviceBufferFull(), deviceRecordStarted(), deviceRecordStopped(), and deviceTriggerReached().

{
    switch (state) {
        case Kwave::REC_UNINITIALIZED:       return "REC_UNINITIALIZED";
        case Kwave::REC_EMPTY:               return "REC_EMPTY";
        case Kwave::REC_BUFFERING:           return "REC_BUFFERING";
        case Kwave::REC_WAITING_FOR_TRIGGER: return "REC_WAITING_FOR_TRIGGER";
        case Kwave::REC_PRERECORDING:        return "REC_PRERECORDING";
        case Kwave::REC_RECORDING:           return "REC_RECORDING";
        case Kwave::REC_PAUSED:              return "REC_PAUSED";
        case Kwave::REC_DONE:                return "REC_DONE";
    }
    return "-INVALID-";
}

Here is the caller graph for this function:

Member Data Documentation

m_empty

bool Kwave::RecordController::m_empty

private

if true the current file is empty

Definition at line 125 of file RecordController.h.

Referenced by deviceRecordStarted(), deviceRecordStopped(), setEmpty(), and setInitialized().

m_enable_prerecording

bool Kwave::RecordController::m_enable_prerecording

private

use prerecording

Definition at line 122 of file RecordController.h.

Referenced by deviceBufferFull(), deviceTriggerReached(), and enablePrerecording().

m_next_state

Kwave::RecordState Kwave::RecordController::m_next_state

private

state of the recording engine after finishing the last action, not needed for all state changes.

Definition at line 116 of file RecordController.h.

Referenced by actionReset(), actionStart(), actionStop(), deviceBufferFull(), deviceRecordStarted(), deviceRecordStopped(), deviceTriggerReached(), and setInitialized().

m_state

Kwave::RecordState Kwave::RecordController::m_state

private

current state of the recording engine

Definition at line 110 of file RecordController.h.

Referenced by actionPause(), actionReset(), actionStart(), actionStop(), deviceBufferFull(), deviceRecordStarted(), deviceRecordStopped(), deviceTriggerReached(), and setInitialized().

m_trigger_set

bool Kwave::RecordController::m_trigger_set

private

use a trigger

Definition at line 119 of file RecordController.h.

Referenced by deviceBufferFull(), deviceTriggerReached(), and enableTrigger().

---

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

• plugins/record/RecordController.h
• plugins/record/RecordController.cpp