Kwave::PlaybackController Class Reference

#include <PlaybackController.h>

Inheritance diagram for Kwave::PlaybackController:

Collaboration diagram for Kwave::PlaybackController:

Public Slots
void	playbackStart ()
void	playbackLoop ()
void	playbackPause ()
void	playbackContinue ()
void	playbackStop ()
void	reload ()
void	seekTo (sample_index_t pos)
void	seekDone (sample_index_t pos)
void	updatePlaybackPos (sample_index_t pos)
void	playbackDone ()

Signals
void	sigPlaybackStarted ()
void	sigPlaybackPaused ()
void	sigPlaybackStopped ()
void	sigPlaybackPos (sample_index_t pos)
void	sigSeekDone (sample_index_t pos)
void	sigDevicePlaybackDone ()
void	sigDevicePlaybackPos (sample_index_t pos)
void	sigDeviceSeekDone (sample_index_t pos)

Public Member Functions
	PlaybackController (Kwave::SignalManager &signal_manager)
virtual	~PlaybackController () Q_DECL_OVERRIDE
void	reset ()
bool	loop () const
bool	running () const
bool	paused () const
void	setStartPos (sample_index_t pos)
void	setEndPos (sample_index_t pos)
sample_index_t	startPos () const
sample_index_t	endPos () const
sample_index_t	currentPos () const
void	registerPlaybackDeviceFactory (Kwave::PlaybackDeviceFactory *factory)
void	unregisterPlaybackDeviceFactory (Kwave::PlaybackDeviceFactory *factory)
virtual Kwave::PlayBackDevice *	createDevice (Kwave::playback_method_t method)
Kwave::PlayBackDevice *	openDevice (int tracks, const Kwave::PlayBackParam *playback_params)
void	setDefaultParams (const Kwave::PlayBackParam &params)
void	checkMethod (Kwave::playback_method_t &method)
Public Member Functions inherited from Kwave::Runnable
virtual	~Runnable ()

Protected Member Functions
virtual void	run_wrapper (const QVariant &params) Q_DECL_OVERRIDE

Private Slots
void	closeDevice ()
void	trackSelectionChanged ()

Private Member Functions
void	startDevicePlayBack ()
void	stopDevicePlayBack ()

Private Attributes
Kwave::SignalManager &	m_signal_manager
Kwave::WorkerThread	m_thread
Kwave::PlayBackDevice *	m_device
QMutex	m_lock_device
Kwave::PlayBackParam	m_playback_params
QMutex	m_lock_playback
bool	m_should_seek
sample_index_t	m_seek_pos
bool	m_track_selection_changed
bool	m_reload_mode
bool	m_loop_mode
bool	m_paused
bool	m_playing
sample_index_t	m_playback_position
sample_index_t	m_playback_start
sample_index_t	m_playback_end
sample_index_t	m_old_first
sample_index_t	m_old_last
QList< Kwave::PlaybackDeviceFactory * >	m_playback_factories

Detailed Description

Provides a generic interface for classes that can contol playback with start, stop, pause and continue. This class is intended to be used or derived in a class that is able to control a playback device by simply startig or stopping playback and can be easily used by some other part of the program that has nothing to do directly with playback. The playback control functions all start with "playback" and are slots that are intended to be connected to some simple gui elements like toolbar buttons or menu entries.

This class internally manages the logic and handling of the playback position.

Definition at line 53 of file PlaybackController.h.

Constructor & Destructor Documentation

PlaybackController()

Kwave::PlaybackController::PlaybackController ( Kwave::SignalManager &  signal_manager )

explicit

Default constructor

Definition at line 42 of file PlaybackController.cpp.

References closeDevice(), Kwave::connect(), m_signal_manager, playbackDone(), sigDevicePlaybackDone(), and trackSelectionChanged().

    :m_signal_manager(signal_manager), m_thread(this, QVariant()),
     m_device(Q_NULLPTR), m_lock_device(), m_playback_params(),
     m_lock_playback(), m_should_seek(false), m_seek_pos(0),
     m_track_selection_changed(false),
     m_reload_mode(false), m_loop_mode(false), m_paused(false),
     m_playing(false), m_playback_position(0), m_playback_start(0),
     m_playback_end(0), m_old_first(0), m_old_last(0),
     m_playback_factories()
{

    connect(this, SIGNAL(sigDevicePlaybackDone()),
            this, SLOT(playbackDone()));
    connect(this, SIGNAL(sigDevicePlaybackDone()),
            this, SLOT(closeDevice()),
            Qt::QueuedConnection);
    connect(&m_signal_manager, SIGNAL(sigTrackSelectionChanged(bool)),
            this,              SLOT(trackSelectionChanged()));

}

Here is the call graph for this function:

~PlaybackController()

Kwave::PlaybackController::~PlaybackController ( )

virtual

Destructor

Definition at line 66 of file PlaybackController.cpp.

References playbackStop().

{
    playbackStop();
}

Here is the call graph for this function:

Member Function Documentation

checkMethod()

void Kwave::PlaybackController::checkMethod

(

Kwave::playback_method_t &

method

)

Checks whether a playback method is supported and returns the next best match if not.

Parameters

method

reference to a playback method, can be modified

Definition at line 556 of file PlaybackController.cpp.

References DBG, Kwave::TypesMap< IDX, DATA >::findFromData(), m_playback_factories, Kwave::TypesMap< IDX, DATA >::name(), Kwave::PLAYBACK_INVALID, Kwave::PLAYBACK_NONE, and Kwave::PlaybackDeviceFactory::supportedMethods().

Referenced by openDevice(), and Kwave::PlayBackDialog::setMethod().

{
    QList<Kwave::playback_method_t> all_methods;

    // create a list of all supported playback methods
    foreach (Kwave::PlaybackDeviceFactory *f, m_playback_factories) {
        QList<Kwave::playback_method_t> methods = f->supportedMethods();

        // return immediately on a direct match
        if (methods.contains(method)) return;

        // otherwise accumulate all found methods
        foreach (Kwave::playback_method_t m, methods)
            if (!all_methods.contains(m))
                all_methods.append(m);
    }

    // no direct match found: take the best match (lowest number)
    Kwave::playback_method_t best = Kwave::PLAYBACK_INVALID;
    foreach (Kwave::playback_method_t m, all_methods) {
        if (m == Kwave::PLAYBACK_NONE) continue; // not a valid selection
        if (m < best) best = m;
    }

    Kwave::PlayBackTypesMap map;
    qDebug("playback method '%s' (%d) not supported "
           "-> falling back to '%s' (%d)",
           DBG(map.name(map.findFromData(method))), static_cast<int>(method),
           DBG(map.name(map.findFromData(best))),   static_cast<int>(best)
    );

    method = best;
}

Here is the call graph for this function:

Here is the caller graph for this function:

closeDevice

void Kwave::PlaybackController::closeDevice ( )

privateslot

Closes the playback device, deletes the instance of the PlayBackDevice and sets m_device to 0.

See also

m_device

PlayBackDevice

Definition at line 542 of file PlaybackController.cpp.

References m_device, and m_lock_device.

Referenced by PlaybackController(), and stopDevicePlayBack().

{
    Kwave::PlayBackDevice *dev = Q_NULLPTR;
    if (m_device) {
        // NOTE: we could get a recursion here if we delete with the lock
        //       held, if the device calls processEvents during shutdown
        QMutexLocker lock_for_delete(&m_lock_device);
        dev = m_device;
        m_device = Q_NULLPTR;
    }
    delete dev;
}

Here is the caller graph for this function:

createDevice()

Kwave::PlayBackDevice * Kwave::PlaybackController::createDevice ( Kwave::playback_method_t  method )

virtual

Create a playback device matching the given playback method.

Parameters

method

a playback_method_t (e.g. Pulse, ALSA, OSS...)

Returns

a new PlayBackDevice or 0 if failed

Definition at line 591 of file PlaybackController.cpp.

References Kwave::PlaybackDeviceFactory::createDevice(), m_playback_factories, and Kwave::PlaybackDeviceFactory::supportedMethods().

Referenced by openDevice(), and Kwave::PlayBackDialog::setMethod().

{
    // locate the corresponding playback device factory (plugin)
    Kwave::PlaybackDeviceFactory *factory = Q_NULLPTR;
    foreach (Kwave::PlaybackDeviceFactory *f, m_playback_factories) {
        Q_ASSERT(f);
        if (f && f->supportedMethods().contains(method)) {
            factory = f;
            break;
        }
    }
    if (!factory) return Q_NULLPTR;

    // create a new device instance, using the given method
    return factory->createDevice(method);
}

Here is the call graph for this function:

Here is the caller graph for this function:

currentPos()

sample_index_t Kwave::PlaybackController::currentPos

(

)

const

returns the current position of the playback pointer

Definition at line 303 of file PlaybackController.cpp.

References m_playback_position.

Referenced by startDevicePlayBack().

{
    return m_playback_position;
}

Here is the caller graph for this function:

endPos()

sample_index_t Kwave::PlaybackController::endPos

(

)

const

returns the position where the playback ends

Definition at line 297 of file PlaybackController.cpp.

References m_playback_end.

{
    return m_playback_end;
}

loop()

bool Kwave::PlaybackController::loop

(

)

const

returns the loop mode flag

Definition at line 261 of file PlaybackController.cpp.

References m_loop_mode.

{
    return m_loop_mode;
}

openDevice()

Kwave::PlayBackDevice * Kwave::PlaybackController::openDevice	(	int	tracks,
		const Kwave::PlayBackParam *	playback_params
	)

Creates, opens and initializes a playback device.

Parameters

tracks	number of tracks, if negative use the setting of playback_params
playback_params	points to a structure with playback parameters. If null, the default parameters of the current signal will be used

Returns

a pointer to an opened PlayBackDevice or null if failed

See also

PlayBackDevice

Definition at line 610 of file PlaybackController.cpp.

References Kwave::PlayBackParam::bits_per_sample, Kwave::PlayBackParam::bufbase, Kwave::PlayBackParam::channels, checkMethod(), createDevice(), Kwave::PlayBackParam::device, Kwave::MessageBox::error(), Kwave::SignalManager::isClosed(), Kwave::SignalManager::isEmpty(), m_playback_params, m_signal_manager, Kwave::PlayBackParam::method, Kwave::PlayBackDevice::open(), Kwave::SignalManager::parentWidget(), Kwave::PLAYBACK_NONE, Kwave::PlayBackParam::rate, Kwave::SignalManager::rate(), and Kwave::SignalManager::selectedTracks().

Referenced by Kwave::PluginManager::openMultiTrackPlayback(), and startDevicePlayBack().

{
    // take playback parameters if given,
    // otherwise fall back to current defaults
    Kwave::PlayBackParam params = (playback_params) ?
        *playback_params : m_playback_params;

    // if no playback parameters specified or no method selected:
    // -> auto-detect best
    if (!playback_params || (params.method == PLAYBACK_NONE))
        checkMethod(params.method);

    if (!playback_params) {
        if (!m_signal_manager.isClosed() && !m_signal_manager.isEmpty()) {
            params.rate     = m_signal_manager.rate();
            params.channels = m_signal_manager.selectedTracks().count();
        }
    }

    // try to create a new device, using the given playback method
    Kwave::PlayBackDevice *device = createDevice(params.method);
    if (!device) return Q_NULLPTR;

    // override the number of tracks if not negative
    if (tracks > 0) params.channels = tracks;

    // open the playback device with it's default parameters
    // open and initialize the device
    QString result = device->open(
        params.device,
        params.rate,
        params.channels,
        params.bits_per_sample,
        params.bufbase
    );
    if (result.length()) {
        qWarning("PlayBackPlugin::openDevice(): opening the device failed.");

        // delete the device if it did not open
        delete device;
        device = Q_NULLPTR;

        // show an error message box
        Kwave::MessageBox::error(m_signal_manager.parentWidget(), result,
            i18n("Unable to open '%1'",
            params.device.section(QLatin1Char('|'), 0, 0)));
    }


    return device;
}

Here is the call graph for this function:

Here is the caller graph for this function:

paused()

bool Kwave::PlaybackController::paused

(

)

const

returns true if the playback is paused

Definition at line 273 of file PlaybackController.cpp.

References m_paused.

{
    return m_paused;
}

playbackContinue

void Kwave::PlaybackController::playbackContinue ( )

slot

Continues the playback at the position where it has been stopped by the playbackPause() command. If the last playback pointer has become invalid or is not available (less 0), this function will do the same as playbackStart(). This also emits the signal sigPlaybackStarted().

Definition at line 135 of file PlaybackController.cpp.

References m_paused, m_playing, m_reload_mode, playbackStart(), sigPlaybackStarted(), and startDevicePlayBack().

{
    // leave the reload mode in any case
    m_reload_mode = false;

    // if not paused, do the same as start
    if (!m_paused) {
        playbackStart();
        return;
    }

    // else reset the paused flag and start from current position
    startDevicePlayBack();

    m_paused = false;
    m_playing = true;

    emit sigPlaybackStarted();
}

Here is the call graph for this function:

playbackDone

void Kwave::PlaybackController::playbackDone ( )

slot

Updates the status if playback is done

Definition at line 207 of file PlaybackController.cpp.

References m_old_first, m_old_last, m_paused, m_playback_position, m_playing, m_reload_mode, sigPlaybackPaused(), sigPlaybackPos(), sigPlaybackStopped(), and startDevicePlayBack().

Referenced by PlaybackController().

{
    if (m_reload_mode) {
        // if we were in the reload mode, reset the
        // paused flag and start again from current position
        startDevicePlayBack();
        m_paused = false;
        m_playing = true;

        // leave the "reload" mode
        m_reload_mode = false;
        return;
    }

    m_playing = false;
    if (m_paused)
        emit sigPlaybackPaused();
    else {
        emit sigPlaybackPos(m_playback_position);
        emit sigPlaybackStopped();
    }

    m_old_first = 0;
    m_old_last = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

playbackLoop

void Kwave::PlaybackController::playbackLoop ( )

slot

(Re-)starts the playback in loop mode (like with playbackStart(). Also emitts sigPlaybackStarted() if playback has successfully been started.

Definition at line 96 of file PlaybackController.cpp.

References m_loop_mode, m_paused, m_playback_position, m_playback_start, m_playing, m_reload_mode, sigPlaybackPos(), sigPlaybackStarted(), sigPlaybackStopped(), startDevicePlayBack(), and stopDevicePlayBack().

{
    // leave the reload mode in any case
    m_reload_mode = false;

    if (m_playing) {
        // first stop playback
        stopDevicePlayBack();
        m_playing = false;
        emit sigPlaybackStopped();
    }

    // (re)start from beginning without loop mode
    m_playback_position = m_playback_start;
    emit sigPlaybackPos(m_playback_position);

    m_loop_mode = true;
    m_paused = false;
    startDevicePlayBack();

    m_playing = true;
    emit sigPlaybackStarted();
}

Here is the call graph for this function:

playbackPause

void Kwave::PlaybackController::playbackPause ( )

slot

Pauses the playback. Causes sigPlaybackDone() to be emitted if the current buffer has played out. The current playback pointer will stay at it's current position.

Definition at line 121 of file PlaybackController.cpp.

References m_paused, m_playing, m_reload_mode, and stopDevicePlayBack().

{
    // leave the reload mode in any case
    m_reload_mode = false;

    if (!m_playing) return; // no effect if not playing

    m_paused = true;

    // stop playback for now and set the paused flag
    stopDevicePlayBack();
}

Here is the call graph for this function:

playbackStart

void Kwave::PlaybackController::playbackStart ( )

slot

(Re-)starts the playback. If playback has successfully been started, the signal sigPlaybackStarted() will be emitted.

Definition at line 72 of file PlaybackController.cpp.

References m_loop_mode, m_paused, m_playback_position, m_playback_start, m_playing, m_reload_mode, sigPlaybackPos(), sigPlaybackStarted(), sigPlaybackStopped(), startDevicePlayBack(), and stopDevicePlayBack().

Referenced by Kwave::SignalManager::executeCommand(), and playbackContinue().

{
    // leave the reload mode in any case
    m_reload_mode = false;

    if (m_playing) {
        // first stop playback
        stopDevicePlayBack();
        emit sigPlaybackStopped();
    }

    // (re)start from beginning without loop mode
    m_playback_position = m_playback_start;
    emit sigPlaybackPos(m_playback_position);

    m_loop_mode = false;
    m_paused = false;
    m_playing = true;
    emit sigPlaybackStarted();

    startDevicePlayBack();
}

Here is the call graph for this function:

Here is the caller graph for this function:

playbackStop

void Kwave::PlaybackController::playbackStop ( )

slot

Stopps playback / loop. Like playbackPause(), but resets the playback pointer back to the start.

Definition at line 156 of file PlaybackController.cpp.

References m_paused, m_playing, m_reload_mode, sigPlaybackStopped(), and stopDevicePlayBack().

Referenced by Kwave::SignalManager::close(), and ~PlaybackController().

{
    // leave the reload mode in any case
    m_reload_mode = false;

    // stopped in pause state
    if (m_paused) {
        m_playing = false;
        m_paused = false;
        emit sigPlaybackStopped();
    }
    if (!m_playing) return; // already stopped
    stopDevicePlayBack();
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerPlaybackDeviceFactory()

void Kwave::PlaybackController::registerPlaybackDeviceFactory

(

Kwave::PlaybackDeviceFactory *

factory

)

Registers a PlaybackDeviceFactory

Definition at line 672 of file PlaybackController.cpp.

References m_playback_factories.

Referenced by Kwave::PlayBackPlugin::load().

{
    m_playback_factories.append(factory);
}

Here is the caller graph for this function:

reload

void Kwave::PlaybackController::reload ( )

slot

If playback is currently running, it will be paused and then restarted with current track and time selection.

Definition at line 234 of file PlaybackController.cpp.

References m_paused, m_playing, m_reload_mode, and stopDevicePlayBack().

{
    if (!m_playing || m_paused) return; // no effect if not playing or paused

    // enter the "reload" mode
    m_reload_mode = true;

    // stop playback for now and set the paused flag
    m_paused = true;
    stopDevicePlayBack();
}

Here is the call graph for this function:

reset()

void Kwave::PlaybackController::reset

(

)

resets start, current position, loop, pause and running flag

Definition at line 247 of file PlaybackController.cpp.

References m_loop_mode, m_paused, m_playback_position, m_playback_start, m_playing, m_reload_mode, sigPlaybackPos(), and sigPlaybackStopped().

Referenced by Kwave::SignalManager::close().

{
    m_playback_start = 0;
    m_playback_position = 0;
    m_loop_mode = false;
    m_playing = false;
    m_paused = false;
    m_reload_mode = false;

    emit sigPlaybackPos(0);
    emit sigPlaybackStopped();
}

Here is the caller graph for this function:

run_wrapper()

void Kwave::PlaybackController::run_wrapper ( const QVariant &  params )

protectedvirtual

wrapper for our run() function, called from worker thread

Implements Kwave::Runnable.

Definition at line 399 of file PlaybackController.cpp.

References Kwave::SignalManager::allTracks(), Kwave::WorkerThread::cancel(), Kwave::PlayBackParam::channels, Kwave::SampleReader::eof(), Kwave::FullSnapshot, m_device, m_lock_device, m_lock_playback, m_loop_mode, m_playback_end, m_playback_params, m_playback_position, m_playback_start, m_seek_pos, m_should_seek, m_signal_manager, m_thread, m_track_selection_changed, Kwave::PlayBackParam::rate, Kwave::MultiTrackReader::reset(), SCREEN_REFRESHES_PER_SECOND, Kwave::MultiTrackReader::seek(), seekDone(), Kwave::SignalManager::selectedTracks(), Kwave::WorkerThread::shouldStop(), sigDevicePlaybackDone(), Kwave::MultiTrackReader::skip(), startPos(), Kwave::toUint(), updatePlaybackPos(), and Kwave::PlayBackDevice::write().

{
    Q_UNUSED(params);

    Kwave::MixerMatrix *mixer = Q_NULLPTR;
    sample_index_t first      = m_playback_start;
    sample_index_t last       = m_playback_end;
    unsigned int out_channels = m_playback_params.channels;

    QList<unsigned int> all_tracks = m_signal_manager.allTracks();
    unsigned int tracks = all_tracks.count();
    QList<unsigned int> audible_tracks = m_signal_manager.selectedTracks();
    unsigned int audible_count = audible_tracks.count();

    // get the list of selected channels
    if (!tracks || !m_device) {
        // not even one selected track or no (open) device
        qDebug("PlaybackController::run(): no audible track(s) !");
        emit sigDevicePlaybackDone();
        return;
    }

    // set up a set of sample reader (streams)
    Kwave::MultiTrackReader input(
        Kwave::FullSnapshot,
        m_signal_manager, all_tracks, first, last);

    // create a new translation matrix for mixing up/down to the desired
    // number of output channels
    m_track_selection_changed = false;

    // loop until process is stopped
    // or run once if not in loop mode
    Kwave::SampleArray in_samples(tracks);
    Kwave::SampleArray out_samples(out_channels);
    sample_index_t pos = m_playback_position;
    updatePlaybackPos(pos);

    // counter for refresh of the playback position
    unsigned int pos_countdown = 0;

    do {

        // if current position is after start -> skip the passed
        // samples (this happens when resuming after a pause)
        if (pos > first) input.skip(pos - first);

        while ((pos++ <= last) && !m_thread.shouldStop()) {
            unsigned int x;
            unsigned int y;
            bool seek_again = false;
            bool seek_done  = false;

            {
                QMutexLocker _lock(&m_lock_playback);

                // check for track selection change (need for new mixer)
                if (m_track_selection_changed) {
                    if (mixer) delete mixer;
                    mixer = Q_NULLPTR;
                    m_track_selection_changed = false;
                }

                if (!mixer) {
                    audible_tracks = m_signal_manager.selectedTracks();
                    audible_count = audible_tracks.count();
                    mixer = new Kwave::MixerMatrix(audible_count, out_channels);
                    Q_ASSERT(mixer);
                    if (!mixer) break;
                    seek_again = true; // re-synchronize all reader positions
                }

                // check for seek requests
                if (m_should_seek && (m_seek_pos != pos)) {
                    if (m_seek_pos < first) m_seek_pos = first;
                    if (m_seek_pos > last)  { pos = last; break; }
                    pos = m_seek_pos;
                    m_should_seek = false;
                    seek_again = true;
                    seek_done  = true;
                }
            }

            if (seek_again) input.seek(pos);
            if (seek_done)  seekDone(pos);;

            // fill input buffer with samples
            for (x = 0; x < audible_count; ++x) {
                in_samples[x] = 0;
                Kwave::SampleReader *stream = input[audible_tracks[x]];
                Q_ASSERT(stream);
                if (!stream) continue;

                if (!stream->eof()) (*stream) >> in_samples[x];
            }

            // multiply matrix with input to get output
            const Kwave::SampleArray &in = in_samples;
            for (y = 0; y < out_channels; ++y) {
                double sum = 0;
                for (x = 0; x < audible_count; ++x) {
                    sum += static_cast<double>(in[x]) * (*mixer)[x][y];
                }
                out_samples[y] = static_cast<sample_t>(sum);
            }

            // write samples to the playback device
            int result = -1;
            {
                QMutexLocker lock(&m_lock_device);
                if (m_device)
                    result = m_device->write(out_samples);
            }
            if (result) {
                m_thread.cancel();
                pos = last;
            }

            // update the playback position if timer elapsed
            if (!pos_countdown) {
                pos_countdown = Kwave::toUint(ceil(
                    m_playback_params.rate / SCREEN_REFRESHES_PER_SECOND));
                updatePlaybackPos(pos);
            } else {
                --pos_countdown;
            }
        }

        // maybe we loop. in this case the playback starts
        // again from the left marker
        if (m_loop_mode && !m_thread.shouldStop()) {
            input.reset();
            pos = startPos();
        }

    } while (m_loop_mode && !m_thread.shouldStop());

    // playback is done
    emit sigDevicePlaybackDone();
//     qDebug("PlaybackController::run() done.");
}

Here is the call graph for this function:

running()

bool Kwave::PlaybackController::running

(

)

const

returns true if the playback is running

Definition at line 267 of file PlaybackController.cpp.

References m_playing.

Referenced by Kwave::SignalView::mousePressEvent(), and Kwave::SignalView::mouseReleaseEvent().

{
    return m_playing;
}

Here is the caller graph for this function:

seekDone

void Kwave::PlaybackController::seekDone ( sample_index_t  pos )

slot

Called when the seek has finished

Definition at line 194 of file PlaybackController.cpp.

References sigSeekDone().

Referenced by run_wrapper(), and seekTo().

{
    emit sigSeekDone(pos);
}

Here is the caller graph for this function:

seekTo

void Kwave::PlaybackController::seekTo ( sample_index_t  pos )

slot

Seeks to a new position

Definition at line 172 of file PlaybackController.cpp.

References m_lock_playback, m_paused, m_playback_end, m_playback_start, m_seek_pos, m_should_seek, seekDone(), and updatePlaybackPos().

{
    if (pos < m_playback_start) pos = m_playback_start;
    if (pos > m_playback_end)   pos = m_playback_end;

    {
        QMutexLocker lock(&m_lock_playback);
        qDebug("seekTo(%llu)", pos);
        m_seek_pos    = pos;
        m_should_seek = true;
    }

    if (m_paused) {
        // if playback is paused, we want an update of the playback
        // position anyway. as this will not come from the device layer,
        // fake an update right here
        updatePlaybackPos(pos);
        seekDone(pos);
    }
}

Here is the call graph for this function:

setDefaultParams()

void Kwave::PlaybackController::setDefaultParams

(

const Kwave::PlayBackParam &

params

)

Sets default playback parameters, for use next time playback is started

Parameters

params

new playback parameters

Definition at line 665 of file PlaybackController.cpp.

References m_playback_params.

Referenced by Kwave::PlayBackPlugin::load(), and Kwave::PlayBackPlugin::setup().

{
    m_playback_params = params;
}

Here is the caller graph for this function:

setEndPos()

void Kwave::PlaybackController::setEndPos

(

sample_index_t

pos

)

sets a new end position

Definition at line 285 of file PlaybackController.cpp.

References m_playback_end.

Referenced by startDevicePlayBack().

{
    m_playback_end = pos;
}

Here is the caller graph for this function:

setStartPos()

void Kwave::PlaybackController::setStartPos

(

sample_index_t

pos

)

sets a new start position

Definition at line 279 of file PlaybackController.cpp.

References m_playback_start.

Referenced by startDevicePlayBack().

{
    m_playback_start = pos;
}

Here is the caller graph for this function:

sigDevicePlaybackDone

void Kwave::PlaybackController::sigDevicePlaybackDone ( )

signal

Signals that playback has stopped (sent from worker thread).

Referenced by PlaybackController(), run_wrapper(), startDevicePlayBack(), and stopDevicePlayBack().

Here is the caller graph for this function:

sigDevicePlaybackPos

void Kwave::PlaybackController::sigDevicePlaybackPos ( sample_index_t  pos )

signal

Emits the current playback position (from worker thread)

sigDeviceSeekDone

void Kwave::PlaybackController::sigDeviceSeekDone ( sample_index_t  pos )

signal

Emitted after a successful seek operation (from worker thread)

sigPlaybackPaused

void Kwave::PlaybackController::sigPlaybackPaused ( )

signal

Signals that playback has been paused.

Referenced by playbackDone().

Here is the caller graph for this function:

sigPlaybackPos

void Kwave::PlaybackController::sigPlaybackPos ( sample_index_t  pos )

signal

Emits the current position of the playback pointer

Referenced by playbackDone(), playbackLoop(), playbackStart(), reset(), and updatePlaybackPos().

Here is the caller graph for this function:

sigPlaybackStarted

void Kwave::PlaybackController::sigPlaybackStarted ( )

signal

Signals that playback has started.

Referenced by playbackContinue(), playbackLoop(), and playbackStart().

Here is the caller graph for this function:

sigPlaybackStopped

void Kwave::PlaybackController::sigPlaybackStopped ( )

signal

Signals that playback has stopped.

Referenced by playbackDone(), playbackLoop(), playbackStart(), playbackStop(), and reset().

Here is the caller graph for this function:

sigSeekDone

void Kwave::PlaybackController::sigSeekDone ( sample_index_t  pos )

signal

Emits the current position after a seek operation

Referenced by seekDone().

Here is the caller graph for this function:

startDevicePlayBack()

void Kwave::PlaybackController::startDevicePlayBack ( )

private

Starts playback device (and worker thread)

Definition at line 309 of file PlaybackController.cpp.

References currentPos(), Kwave::Selection::first(), Kwave::Selection::last(), Kwave::SignalManager::length(), m_device, m_lock_device, m_old_first, m_old_last, m_paused, m_playback_params, m_signal_manager, m_thread, openDevice(), Kwave::PlayBackParam::rate, Kwave::SignalManager::rate(), Kwave::SignalManager::selection(), setEndPos(), setStartPos(), sigDevicePlaybackDone(), Kwave::WorkerThread::start(), and updatePlaybackPos().

Referenced by playbackContinue(), playbackDone(), playbackLoop(), and playbackStart().

{
    // set the real sample rate for playback from the signal itself
    m_playback_params.rate = m_signal_manager.rate();

    QMutexLocker lock_for_delete(&m_lock_device);

    // remove the old device if still one exists
    if (m_device) {
        qWarning("PlaybackController::startDevicePlayBack(): "
                 "removing stale instance");
        delete m_device;
        m_device = Q_NULLPTR;
    }

    // open the device and abort if not possible

//     qDebug("PlaybackController::startDevicePlayBack(), device='%s'",
//           DBG(m_playback_params.device));
    m_device = openDevice(-1, &m_playback_params);
    if (!m_device) {
        // simulate a "playback done" on errors
        emit sigDevicePlaybackDone();
        return;
    }

    sample_index_t first = m_signal_manager.selection().first();
    sample_index_t last  = m_signal_manager.selection().last();

    if (m_paused) {
        // continue after pause
        if ((m_old_first != first) || (m_old_last != last)) {
            // selection has changed
            if (first != last) {
                // something selected -> set new range
                setStartPos(first);
                setEndPos(last);

                sample_index_t pos = currentPos();
                if ((pos < first) || (pos > last)) {
                    // completely new area selected, or the right margin
                    // has been moved before the current playback pointer
                    // -> play from start of new selection
                    updatePlaybackPos(first);
                }
            } else {
                // nothing selected -> select all and move to position
                setStartPos(first);
                setEndPos(m_signal_manager.length() - 1);
            }
        }
    } else {
        // determine first and last sample if not in paused mode"
        if (first == last) {
            // nothing selected -> play from cursor position
            setStartPos(first);
            setEndPos(m_signal_manager.length() - 1);
        } else {
            // play only in selection
            setStartPos(first);
            setEndPos(last);
        }
        updatePlaybackPos(first);
    }

    m_old_first = first;
    m_old_last = last;

    m_thread.start();
}

Here is the call graph for this function:

Here is the caller graph for this function:

startPos()

sample_index_t Kwave::PlaybackController::startPos

(

)

const

returns the position where the playback starts

Definition at line 291 of file PlaybackController.cpp.

References m_playback_start.

Referenced by run_wrapper().

{
    return m_playback_start;
}

Here is the caller graph for this function:

stopDevicePlayBack()

void Kwave::PlaybackController::stopDevicePlayBack ( )

private

Stops the playback device (and worker thread)

Definition at line 381 of file PlaybackController.cpp.

References Kwave::WorkerThread::cancel(), closeDevice(), m_thread, and sigDevicePlaybackDone().

Referenced by playbackLoop(), playbackPause(), playbackStart(), playbackStop(), and reload().

{
    m_thread.cancel();
    if (!m_thread.isRunning()) {
        qDebug("PlaybackController::stopDevicePlayBack() - not running");
        emit sigDevicePlaybackDone();
    }
    closeDevice();
}

Here is the call graph for this function:

Here is the caller graph for this function:

trackSelectionChanged

void Kwave::PlaybackController::trackSelectionChanged ( )

privateslot

updates the mixer matrix if the track selection has changed

Definition at line 392 of file PlaybackController.cpp.

References m_lock_playback, and m_track_selection_changed.

Referenced by PlaybackController().

{
    QMutexLocker lock(&m_lock_playback);
    m_track_selection_changed = true;
}

Here is the caller graph for this function:

unregisterPlaybackDeviceFactory()

void Kwave::PlaybackController::unregisterPlaybackDeviceFactory

(

Kwave::PlaybackDeviceFactory *

factory

)

Unregisters a PlaybackDeviceFactory

Definition at line 679 of file PlaybackController.cpp.

References m_playback_factories.

Referenced by Kwave::PlayBackPlugin::unload().

{
    m_playback_factories.removeAll(factory);
}

Here is the caller graph for this function:

updatePlaybackPos

void Kwave::PlaybackController::updatePlaybackPos ( sample_index_t  pos )

slot

Updates the current playback position

Definition at line 200 of file PlaybackController.cpp.

References m_playback_position, and sigPlaybackPos().

Referenced by run_wrapper(), seekTo(), and startDevicePlayBack().

{
    m_playback_position = pos;
    emit sigPlaybackPos(m_playback_position); // TODO => per TIMER !!!
}

Here is the caller graph for this function:

Member Data Documentation

m_device

Kwave::PlayBackDevice* Kwave::PlaybackController::m_device

private

The playback device used for playback

Definition at line 274 of file PlaybackController.h.

Referenced by closeDevice(), run_wrapper(), and startDevicePlayBack().

m_lock_device

QMutex Kwave::PlaybackController::m_lock_device

private

Mutex for locking access to the playback device

Definition at line 277 of file PlaybackController.h.

Referenced by closeDevice(), run_wrapper(), and startDevicePlayBack().

m_lock_playback

QMutex Kwave::PlaybackController::m_lock_playback

private

Mutex for locking access to members that control the playback loop, like m_should_seek, m_seek_pos and m_mixer

Definition at line 286 of file PlaybackController.h.

Referenced by run_wrapper(), seekTo(), and trackSelectionChanged().

m_loop_mode

bool Kwave::PlaybackController::m_loop_mode

private

if set to true, the playback will be done in loop mode

Definition at line 306 of file PlaybackController.h.

Referenced by loop(), playbackLoop(), playbackStart(), reset(), and run_wrapper().

m_old_first

sample_index_t Kwave::PlaybackController::m_old_first

private

Start of the selection when playback started

Definition at line 324 of file PlaybackController.h.

Referenced by playbackDone(), and startDevicePlayBack().

m_old_last

sample_index_t Kwave::PlaybackController::m_old_last

private

End of the selection when playback started

Definition at line 327 of file PlaybackController.h.

Referenced by playbackDone(), and startDevicePlayBack().

m_paused

bool Kwave::PlaybackController::m_paused

private

if true, playback is only paused and can be continued

Definition at line 309 of file PlaybackController.h.

Referenced by paused(), playbackContinue(), playbackDone(), playbackLoop(), playbackPause(), playbackStart(), playbackStop(), reload(), reset(), seekTo(), and startDevicePlayBack().

m_playback_end

sample_index_t Kwave::PlaybackController::m_playback_end

private

the end position for playback

Definition at line 321 of file PlaybackController.h.

Referenced by endPos(), run_wrapper(), seekTo(), and setEndPos().

m_playback_factories

QList<Kwave::PlaybackDeviceFactory *> Kwave::PlaybackController::m_playback_factories

private

list of playback device factories

Definition at line 330 of file PlaybackController.h.

Referenced by checkMethod(), createDevice(), registerPlaybackDeviceFactory(), and unregisterPlaybackDeviceFactory().

m_playback_params

Kwave::PlayBackParam Kwave::PlaybackController::m_playback_params

private

the parameters used for playback

Definition at line 280 of file PlaybackController.h.

Referenced by openDevice(), run_wrapper(), setDefaultParams(), and startDevicePlayBack().

m_playback_position

sample_index_t Kwave::PlaybackController::m_playback_position

private

the current play position

Definition at line 315 of file PlaybackController.h.

Referenced by currentPos(), playbackDone(), playbackLoop(), playbackStart(), reset(), run_wrapper(), and updatePlaybackPos().

m_playback_start

sample_index_t Kwave::PlaybackController::m_playback_start

private

the start position for playback

Definition at line 318 of file PlaybackController.h.

Referenced by playbackLoop(), playbackStart(), reset(), run_wrapper(), seekTo(), setStartPos(), and startPos().

m_playing

bool Kwave::PlaybackController::m_playing

private

is set to true if the playback has been started

Definition at line 312 of file PlaybackController.h.

Referenced by playbackContinue(), playbackDone(), playbackLoop(), playbackPause(), playbackStart(), playbackStop(), reload(), reset(), and running().

m_reload_mode

bool Kwave::PlaybackController::m_reload_mode

private

If true, we are in "reload" mode. In this mode the playback is paused and continued without emitting a sigPlaybackDone. This is useful if playback parameters or signal selection has changed during playback.

Definition at line 303 of file PlaybackController.h.

Referenced by playbackContinue(), playbackDone(), playbackLoop(), playbackPause(), playbackStart(), playbackStop(), reload(), and reset().

m_seek_pos

sample_index_t Kwave::PlaybackController::m_seek_pos

private

position to seek to

Definition at line 292 of file PlaybackController.h.

Referenced by run_wrapper(), and seekTo().

m_should_seek

bool Kwave::PlaybackController::m_should_seek

private

if true, m_seek_pos is valid and a seek has been requested

Definition at line 289 of file PlaybackController.h.

Referenced by run_wrapper(), and seekTo().

m_signal_manager

Kwave::SignalManager& Kwave::PlaybackController::m_signal_manager

private

Reference to our signal manager

Definition at line 266 of file PlaybackController.h.

Referenced by openDevice(), PlaybackController(), run_wrapper(), and startDevicePlayBack().

m_thread

Kwave::WorkerThread Kwave::PlaybackController::m_thread

private

Thread that executes the run() member function.

Definition at line 271 of file PlaybackController.h.

Referenced by run_wrapper(), startDevicePlayBack(), and stopDevicePlayBack().

m_track_selection_changed

bool Kwave::PlaybackController::m_track_selection_changed

private

notification flag, true if the track selection has changed

Definition at line 295 of file PlaybackController.h.

Referenced by run_wrapper(), and trackSelectionChanged().

---

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

• libkwave/PlaybackController.h
• libkwave/PlaybackController.cpp