Kwave::SampleRatePlugin Class Reference

#include <SampleRatePlugin.h>

Inheritance diagram for Kwave::SampleRatePlugin:

Collaboration diagram for Kwave::SampleRatePlugin:

Public Member Functions
	SampleRatePlugin (QObject *parent, const QVariantList &args)
virtual	~SampleRatePlugin () 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 ()

Protected Member Functions
int	interpreteParameters (QStringList &params)
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

Private Attributes
QStringList	m_params
double	m_new_rate
bool	m_whole_signal

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)

Detailed Description

Change the sample rate of a signal

Definition at line 36 of file SampleRatePlugin.h.

Constructor & Destructor Documentation

SampleRatePlugin()

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

Constructor

Parameters

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

Definition at line 44 of file SampleRatePlugin.cpp.

    :Kwave::Plugin(parent, args), m_params(), m_new_rate(0.0),
     m_whole_signal(false)
{
}

~SampleRatePlugin()

Kwave::SampleRatePlugin::~SampleRatePlugin ( )

virtual

Destructor

Definition at line 52 of file SampleRatePlugin.cpp.

{
}

Member Function Documentation

interpreteParameters()

int Kwave::SampleRatePlugin::interpreteParameters ( QStringList &  params )

protected

reads values from the parameter list

Parameters

params

list of strings with parameters

Returns

0 if succeeded or negative error code if failed

Definition at line 57 of file SampleRatePlugin.cpp.

References _, m_new_rate, m_params, and m_whole_signal.

Referenced by run().

{
    bool ok = false;
    QString param;

    // set defaults
    m_new_rate     = 44100.0;
    m_whole_signal = false;

    // evaluate the parameter list
    if (params.count() < 1) return -EINVAL;

    param = params[0];
    m_new_rate = param.toDouble(&ok);
    Q_ASSERT(ok);
    if (!ok) return -EINVAL;

    // check whether we should change the whole signal (optional)
    if (params.count() == 2) {
        if (params[1] != _("all"))
            return -EINVAL;
        m_whole_signal = true;
    }

    // all parameters accepted
    m_params = params;

    return 0;
}

Here is the caller graph for this function:

run()

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

virtual

changes the sample rate

Parameters

params

list of strings with parameters

Reimplemented from Kwave::Plugin.

Definition at line 88 of file SampleRatePlugin.cpp.

References Kwave::SignalManager::allTracks(), Kwave::connect(), Kwave::MetaDataList::copy(), Kwave::SignalManager::deleteRange(), Kwave::MetaDataList::deleteRange(), Kwave::MultiTrackReader::eof(), Kwave::MultiWriter::flush(), Kwave::MultiTrackSource< SOURCE, INITIALIZE >::goOn(), Kwave::MetaData::hasProperty(), Kwave::SignalManager::insertSpace(), interpreteParameters(), m_new_rate, m_whole_signal, Kwave::MetaDataList::merge(), Kwave::SignalManager::metaData(), Kwave::Overwrite, Kwave::MetaData::positionBoundPropertyNames(), Kwave::FileInfo::rate(), Kwave::Plugin::selection(), Kwave::SignalManager::selectRange(), Kwave::StreamObject::setAttribute(), Kwave::SignalManager::setFileInfo(), Kwave::Plugin::setProgressText(), Kwave::FileInfo::setRate(), Kwave::Plugin::shouldStop(), Kwave::Plugin::signalLength(), Kwave::Plugin::signalManager(), Kwave::SinglePassForward, Kwave::toInt(), Kwave::SignalManager::tracks(), and Kwave::Plugin::updateProgress().

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

    // parse parameters
    if (interpreteParameters(params) < 0)
        return;

    double old_rate = Kwave::FileInfo(signalManager().metaData()).rate();
    if ((old_rate <= 0) || qFuzzyCompare(old_rate, m_new_rate)) return;

    Kwave::UndoTransactionGuard undo_guard(*this, i18n("Change sample rate"));

    // get the current selection and the list of affected tracks
    sample_index_t first = 0;
    sample_index_t last  = 0;
    sample_index_t length;
    QList<unsigned int> tracks;
    if (m_whole_signal) {
        length = signalLength();
        last   = (length) ? (length - 1) : 0;
        tracks = mgr.allTracks();
    } else {
        length = selection(&tracks, &first, &last, true);
        if ((length == signalLength()) &&
            (tracks.count() == Kwave::toInt(mgr.tracks())))
        {
            // manually selected the whole signal
            m_whole_signal = true;
        }
    }
    qDebug("SampleRatePlugin: from %9lu - %9lu (%9lu)",
           static_cast<unsigned long int>(first),
           static_cast<unsigned long int>(last),
           static_cast<unsigned long int>(length));
    if (!length || tracks.isEmpty()) return;

    // calculate the new length
    double ratio = m_new_rate / old_rate;
    sample_index_t new_length = static_cast<sample_index_t>(length * ratio);
    if ((new_length == length) || !new_length) return;

    // if the new length is bigger than the current length,
    // insert some space at the end
    if (new_length > length) {
        qDebug("SampleRatePlugin: inserting %lu at %lu",
               static_cast<unsigned long int>(new_length - length + 1),
               static_cast<unsigned long int>(last + 1));
        mgr.insertSpace(last + 1, new_length - length + 1, tracks);
    }

    Kwave::MultiTrackReader source(Kwave::SinglePassForward,
        mgr, tracks, first, last);

    // connect the progress dialog
    connect(&source, SIGNAL(progress(qreal)),
            this,  SLOT(updateProgress(qreal)),
             Qt::BlockingQueuedConnection);
    emit setProgressText(
        i18n("Changing sample rate from %1 kHz to %2 kHz...",
             (old_rate   / 1E3), (m_new_rate / 1E3))
    );

    // create the converter
    Kwave::MultiTrackSource<Kwave::RateConverter, true> converter(
        tracks.count(), this);
    converter.setAttribute(SLOT(setRatio(QVariant)), QVariant(ratio));

    // create the writer with the appropriate length
    Kwave::MultiTrackWriter sink(mgr, tracks, Kwave::Overwrite,
        first, first + new_length - 1);

    // connect the objects
    bool ok = true;
    if (ok) ok = Kwave::connect(
        source,    SIGNAL(output(Kwave::SampleArray)),
        converter, SLOT(input(Kwave::SampleArray)));
    if (ok) ok = Kwave::connect(
        converter, SIGNAL(output(Kwave::SampleArray)),
        sink,      SLOT(input(Kwave::SampleArray)));
    if (!ok) {
        return;
    }

    while (!shouldStop() && !source.eof()) {
        source.goOn();
        converter.goOn();
    }

    sink.flush();

    // find out how many samples have been written and delete the leftovers
    sample_index_t written = sink[0]->position() - first;
//     qDebug("SampleRatePlugin: old=%u, expexted=%u, written=%u",
//          length, new_length, written);
    if (written < length) {
        sample_index_t to_delete = length - written;
        mgr.deleteRange(written, to_delete, tracks);
    }

    // adjust meta data locations
    Kwave::MetaDataList meta = mgr.metaData().copy(first, last, tracks);
    if (!meta.isEmpty()) {
        // adjust all positions in the originally selected range
        // NOTE: if the ratio is > 1, work backwards, otherwise forward

        Kwave::MetaDataList::MutableIterator it(meta);
        (ratio > 1) ? it.toBack() : it.toFront();
        while ((ratio > 1) ? it.hasPrevious() : it.hasNext()) {
            Kwave::MetaData &m = (ratio > 1) ?
                it.previous().value() : it.next().value();

            QStringList properties =
                Kwave::MetaData::positionBoundPropertyNames();
            foreach (const QString &property, properties) {
                if (!m.hasProperty(property))
                    continue;

                sample_index_t pos = static_cast<sample_index_t>(
                    m[property].toULongLong());
                if (pos < first) continue;
                if (pos > last)  continue;

                // is in our range -> calculate new position
                pos -= first;
                pos *= ratio;
                pos += first;

                m[property] = pos;
            }
        }

        mgr.metaData().deleteRange(first, last, tracks);
        mgr.metaData().merge(meta);
    }

    // update the selection if it was not empty
    length = selection(Q_NULLPTR, &first, &last, false);
    if (length) {
        if (m_whole_signal) {
            // if whole signal selected -> adjust start and end
            first *= ratio;
            last  *= ratio;
            length = last - first + 1;
        } else {
            // only a portion selected -> adjust only length
            length *= ratio;
        }

        mgr.selectRange(first, length);
    }

    // set the sample rate if we modified the whole signal
    if (m_whole_signal) {
        Kwave::FileInfo info(signalManager().metaData());
        info.setRate(m_new_rate);
        mgr.setFileInfo(info, false);
    }

}

Here is the call graph for this function:

Member Data Documentation

m_new_rate

double Kwave::SampleRatePlugin::m_new_rate

private

new sample rate

Definition at line 73 of file SampleRatePlugin.h.

Referenced by interpreteParameters(), and run().

m_params

QStringList Kwave::SampleRatePlugin::m_params

private

list of parameters

Definition at line 70 of file SampleRatePlugin.h.

Referenced by interpreteParameters().

m_whole_signal

bool Kwave::SampleRatePlugin::m_whole_signal

private

if true, ignore selection and change whole signal

Definition at line 76 of file SampleRatePlugin.h.

Referenced by interpreteParameters(), and run().

---

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

• plugins/samplerate/SampleRatePlugin.h
• plugins/samplerate/SampleRatePlugin.cpp