Kwave::ReversePlugin Class Reference

#include <ReversePlugin.h>

Inheritance diagram for Kwave::ReversePlugin:

Collaboration diagram for Kwave::ReversePlugin:

Classes
struct	SliceParams

Public Member Functions
	ReversePlugin (QObject *parent, const QVariantList &args)
virtual	~ReversePlugin () Q_DECL_OVERRIDE
virtual void	run (QStringList params) Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::Plugin
	Plugin (QObject *parent, const QVariantList &args)
virtual	~Plugin () Q_DECL_OVERRIDE
virtual QString	name () const
virtual QString	description () const
virtual QString	progressText ()
virtual bool	canClose () const
bool	isRunning () const
bool	shouldStop () const
virtual void	load (QStringList &params)
virtual void	unload ()
virtual QStringList *	setup (QStringList &previous_params)
virtual int	start (QStringList &params)
virtual int	stop ()
Kwave::PluginManager &	manager () const
Kwave::SignalManager &	signalManager ()
QWidget *	parentWidget () const
QString	signalName ()
virtual sample_index_t	signalLength ()
virtual double	signalRate ()
virtual const QList< unsigned int >	selectedTracks ()
virtual sample_index_t	selection (QList< unsigned int > *tracks=Q_NULLPTR, sample_index_t *left=Q_NULLPTR, sample_index_t *right=Q_NULLPTR, bool expand_if_empty=false)
virtual void	selectRange (sample_index_t offset, sample_index_t length)
virtual void	migrateToActiveContext ()
Public Member Functions inherited from Kwave::Runnable
virtual	~Runnable ()

Private Slots
virtual void	updateProgress (qreal progress) Q_DECL_OVERRIDE

Private Member Functions
void	reverseSlice (unsigned int track, Kwave::SampleReader *src_a, Kwave::SampleReader *src_b, const Kwave::ReversePlugin::SliceParams &params)
void	reverse (Kwave::SampleArray &buffer)

Additional Inherited Members
Public Slots inherited from Kwave::Plugin
virtual void	setProgressDialogEnabled (bool enable)
virtual void	updateProgress (qreal progress)
virtual void	cancel ()
virtual void	close ()
void	release ()
Signals inherited from Kwave::Plugin
void	sigRunning (Kwave::Plugin *plugin)
void	sigDone (Kwave::Plugin *plugin)
void	sigClosed (Kwave::Plugin *p)
void	sigCommand (const QString &command)
void	setProgressText (const QString &text)
Protected Member Functions inherited from Kwave::Plugin
int	execute (QStringList &params)
void	emitCommand (const QString &command)
void	use ()
void	setPluginManager (Kwave::PluginManager *new_plugin_manager)
virtual void	run_wrapper (const QVariant &params) Q_DECL_OVERRIDE

Detailed Description

Reverses the current selection by exchanging blocks of samples from front and back and reversing their content

Definition at line 37 of file ReversePlugin.h.

Constructor & Destructor Documentation

ReversePlugin()

Kwave::ReversePlugin::ReversePlugin	(	QObject *	parent,
		const QVariantList &	args
	)

Constructor

Parameters

parent	reference to our plugin manager
args	argument list [unused]

Definition at line 47 of file ReversePlugin.cpp.

    :Kwave::Plugin(parent, args)
{
}

~ReversePlugin()

Kwave::ReversePlugin::~ReversePlugin ( )

virtual

Destructor

Definition at line 54 of file ReversePlugin.cpp.

{
}

Member Function Documentation

reverse()

void Kwave::ReversePlugin::reverse ( Kwave::SampleArray &  buffer )

private

reverses the content of an array of samples

Definition at line 205 of file ReversePlugin.cpp.

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

Referenced by reverseSlice().

{
    unsigned int count = buffer.size() >> 1;
    if (count <= 1) return;

    sample_t *a = buffer.data();
    sample_t *b = buffer.data() + (buffer.size() - 1);
    for (; count; count--) {
        sample_t h = *a;
        *a++ = *b;
        *b-- = h;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

reverseSlice()

void Kwave::ReversePlugin::reverseSlice ( unsigned int  track, Kwave::SampleReader *  src_a, Kwave::SampleReader *  src_b, const Kwave::ReversePlugin::SliceParams &  params  )

private

reverse a slice of samples

Parameters

track	index of the track
src_a	reader for reading from the start (forward)
src_b	reader fro reading from the end (backwards)
params	common slice parameters (first/last/block size)

Definition at line 134 of file ReversePlugin.cpp.

References Kwave::Writer::flush(), flush(), Kwave::ReversePlugin::SliceParams::m_block_size, Kwave::ReversePlugin::SliceParams::m_first, Kwave::ReversePlugin::SliceParams::m_last, Kwave::SignalManager::openWriter(), Kwave::Overwrite, Kwave::SampleArray::resize(), reverse(), Kwave::SampleReader::seek(), Kwave::Plugin::signalManager(), and Kwave::toUint().

Referenced by run().

{
    Kwave::SignalManager &signal_manager = signalManager();
    const sample_index_t first      = params.m_first;
    const sample_index_t last       = params.m_last;
    const unsigned int   block_size = params.m_block_size;
    const sample_index_t start_a    = first;
    const sample_index_t start_b    = (last >= block_size) ?
                                      (last - block_size) : 0;
    bool ok = true;

    if (start_a + block_size < start_b) {
        // read from start
        Kwave::SampleArray buffer_a;
        ok &= buffer_a.resize(block_size);
        Q_ASSERT(ok);
        *src_a >> buffer_a;

        // read from end
        Kwave::SampleArray buffer_b;
        ok &= buffer_b.resize(block_size);
        Q_ASSERT(ok);
        src_b->seek(start_b);
        *src_b >> buffer_b;

        // swap the contents
        reverse(buffer_a);
        reverse(buffer_b);

        // write back buffer from the end at the start
        Kwave::Writer *dst_a = signal_manager.openWriter(
            Kwave::Overwrite, track,
            start_a, start_a + block_size - 1);
        Q_ASSERT(dst_a);
        if (!dst_a) return;
        *dst_a << buffer_b;
        dst_a->flush();
        delete dst_a;

        // write back buffer from the start at the end
        Kwave::Writer *dst_b = signal_manager.openWriter(
            Kwave::Overwrite, track,
            start_b, start_b + block_size - 1);
        Q_ASSERT(dst_b);
        if (!dst_b) return;
        *dst_b << buffer_a << flush;
        delete dst_b;
    } else {
        // single buffer with last block
        Kwave::SampleArray buffer;
        ok &= buffer.resize(Kwave::toUint(last - first + 1));
        Q_ASSERT(ok);

        // read from start
        *src_a >> buffer;

        // swap content
        reverse(buffer);

        // write back
        Kwave::Writer *dst = signal_manager.openWriter(
            Kwave::Overwrite, track, first, last);
        if (!dst) return;
        (*dst) << buffer << flush;
        delete dst;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

run()

void Kwave::ReversePlugin::run ( QStringList  params )

virtual

reverses the selection

Parameters

params

list of strings with parameters

Reimplemented from Kwave::Plugin.

Definition at line 59 of file ReversePlugin.cpp.

References _, Kwave::StreamObject::blockSize(), Kwave::connect(), Kwave::ReversePlugin::SliceParams::m_block_size, Kwave::ReversePlugin::SliceParams::m_first, Kwave::ReversePlugin::SliceParams::m_last, Kwave::Plugin::manager(), reverseSlice(), Kwave::Plugin::selection(), Kwave::Plugin::shouldStop(), Kwave::Plugin::signalManager(), Kwave::SinglePassForward, Kwave::SinglePassReverse, Kwave::UndoAction::store(), Kwave::MultiTrackSource< SOURCE, INITIALIZE >::tracks(), and updateProgress().

{
    Kwave::SignalManager &signal_manager = signalManager();

    QSharedPointer<Kwave::UndoTransactionGuard> undo_guard;

    // get the current selection and the list of affected tracks
    QList<unsigned int> tracks;
    sample_index_t first = 0;
    sample_index_t last  = 0;
    sample_index_t length = selection(&tracks, &first, &last, true);
    if (!length || tracks.isEmpty())
        return;

    if ((params.count() != 1) || (params.first() != _("noundo"))) {
        // undo is enabled, create a undo guard
        undo_guard = QSharedPointer<Kwave::UndoTransactionGuard>(
            new(std::nothrow) Kwave::UndoTransactionGuard(
                *this, i18n("Reverse")));
        if (!undo_guard) return;

        // try to save undo information
        Kwave::UndoAction *undo =
            new(std::nothrow) Kwave::UndoReverseAction(manager());
        if (!undo_guard->registerUndoAction(undo))
            return;
        undo->store(signal_manager);
    }

    Kwave::MultiTrackReader source_a(Kwave::SinglePassForward,
        signalManager(), tracks, first, last);
    Kwave::MultiTrackReader source_b(Kwave::SinglePassReverse,
        signalManager(), tracks, first, last);

    // break if aborted
    if (!source_a.tracks() || !source_b.tracks())
        return;

    // connect the progress dialog
    connect(&source_a, SIGNAL(progress(qreal)),
            this,      SLOT(updateProgress(qreal)),
            Qt::BlockingQueuedConnection);

    // use a reasonably big buffer size
    const unsigned int block_size = 5 * source_a.blockSize();

    // loop over the sample range
    while ((first < last) && !shouldStop()) {
        QFutureSynchronizer<void> synchronizer;

        Kwave::ReversePlugin::SliceParams slice_params;
        slice_params.m_first      = first;
        slice_params.m_last       = last;
        slice_params.m_block_size = block_size;

        // loop over all tracks
        for (int i = 0; i < tracks.count(); i++) {
            synchronizer.addFuture(QtConcurrent::run(
                this,
                &Kwave::ReversePlugin::reverseSlice,
                tracks[i], source_a[i], source_b[i],
                slice_params)
            );
        }

        // next positions
        first += block_size;
        last  = (last > block_size) ? (last - block_size) : 0;

        synchronizer.waitForFinished();
    }

}

Here is the call graph for this function:

updateProgress

void Kwave::ReversePlugin::updateProgress ( qreal  progress )

privatevirtualslot

multiplies the progress by factor two and calls Kwave::Plugin::updateProgress

Definition at line 220 of file ReversePlugin.cpp.

References Kwave::Plugin::updateProgress().

Referenced by run().

{
    Kwave::Plugin::updateProgress(progress + progress);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• plugins/reverse/ReversePlugin.h
• plugins/reverse/ReversePlugin.cpp