Kwave::NormalizePlugin Class Reference

#include <NormalizePlugin.h>

Inheritance diagram for Kwave::NormalizePlugin:

Collaboration diagram for Kwave::NormalizePlugin:

Classes
struct	Average

Public Member Functions
	NormalizePlugin (QObject *parent, const QVariantList &args)
virtual	~NormalizePlugin () 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 Member Functions
double	getMaxPower (Kwave::MultiTrackReader &source)
void	getMaxPowerOfTrack (Kwave::SampleReader *reader, Kwave::NormalizePlugin::Average *average, unsigned int window_size)

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

This is a two-pass plugin that determines the average volume level of a signal and then calls the volume plugin to adjust the volume.

Definition at line 43 of file NormalizePlugin.h.

Constructor & Destructor Documentation

NormalizePlugin()

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

Constructor

Parameters

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

Definition at line 56 of file NormalizePlugin.cpp.

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

~NormalizePlugin()

Kwave::NormalizePlugin::~NormalizePlugin ( )

virtual

Destructor

Definition at line 63 of file NormalizePlugin.cpp.

{
}

Member Function Documentation

getMaxPower()

double Kwave::NormalizePlugin::getMaxPower ( Kwave::MultiTrackReader &  source )

private

get the maximum power level of the input

Definition at line 142 of file NormalizePlugin.cpp.

References Kwave::SampleReader::eof(), Kwave::MultiTrackReader::eof(), getMaxPowerOfTrack(), Kwave::NormalizePlugin::Average::n, Kwave::FileInfo::rate(), Kwave::Plugin::shouldStop(), Kwave::Plugin::signalManager(), SMOOTHLEN, Kwave::NormalizePlugin::Average::sum, Kwave::toUint(), and Kwave::MultiTrackSource< SOURCE, INITIALIZE >::tracks().

Referenced by run().

{
    double maxpow = 0.0;
    const unsigned int tracks = source.tracks();
    const double rate = Kwave::FileInfo(signalManager().metaData()).rate();
    const unsigned int window_size = Kwave::toUint(rate / 100);
    if (!window_size) return 0;

    // set up smoothing window buffer
    QVector<Kwave::NormalizePlugin::Average> average(tracks);
    for (unsigned int t = 0; t < tracks; t++) {
        average[t].fifo = QVector<double>(SMOOTHLEN, double(0.0));
        average[t].wp  = 0;
        average[t].n   = 0;
        average[t].sum = 0.0;
        average[t].max = 0.0;
    }

    while (!shouldStop() && !source.eof()) {
        QFutureSynchronizer<void> synchronizer;

        for (unsigned int t = 0; t < tracks; t++) {
            Kwave::SampleReader *reader = source[t];
            if (!reader) continue;
            if (reader->eof()) continue;

            synchronizer.addFuture(QtConcurrent::run(
                this,
                &Kwave::NormalizePlugin::getMaxPowerOfTrack,
                reader, &(average[t]), window_size
            ));
        }
        synchronizer.waitForFinished();
     }

    if (average[0].n < SMOOTHLEN) {
        // if file was too short, calculate power out of what we have
        for (unsigned int t = 0; t < tracks; t++) {
            Kwave::NormalizePlugin::Average &avg = average[t];
            double pow = avg.sum / static_cast<double>(avg.n);
            if (pow > maxpow) maxpow = pow;
        }
    } else {
        // get maximum among all tracks
        for (unsigned int t = 0; t < tracks; t++) {
            double p = average[t].max;
            if (p > maxpow) maxpow = p;
        }
    }

    double level = sqrt(maxpow);
    return level;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getMaxPowerOfTrack()

void Kwave::NormalizePlugin::getMaxPowerOfTrack ( Kwave::SampleReader *  reader, Kwave::NormalizePlugin::Average *  average, unsigned int  window_size  )

private

calculate the maximum power of one track

Parameters

reader	reference to a SampleReader to read from
average	reference to smoothing information
window_size	length of the sliding window for volume detection

Definition at line 197 of file NormalizePlugin.cpp.

References Kwave::StreamObject::blockSize(), Kwave::SampleReader::eof(), Kwave::NormalizePlugin::Average::fifo, Kwave::NormalizePlugin::Average::max, Kwave::NormalizePlugin::Average::n, Kwave::SampleReader::read(), sample2double(), SMOOTHLEN, Kwave::NormalizePlugin::Average::sum, and Kwave::NormalizePlugin::Average::wp.

Referenced by getMaxPower().

{
    Kwave::NormalizePlugin::Average &average = *p_average;
    Kwave::SampleArray data(window_size);
    unsigned int round = 0;
    unsigned int loops = 5 * reader->blockSize() / window_size;
    loops++;

    while ((round++ < loops) && !reader->eof()) {
        unsigned int len = reader->read(data, 0, window_size);

        // calculate power of one block
        double sum = 0;
        const Kwave::SampleArray &in = data;
        for (unsigned int i = 0; i < len; i++) {
            sample_t s = in[i];
            double d   = sample2double(s);
            sum += (d * d);
        }
        double pow = sum / static_cast<double>(len);

        // collect all power values in a FIFO
        unsigned int wp = average.wp;
        average.sum -= average.fifo[wp];
        average.sum += pow;
        average.fifo[wp] = pow;
        if (++wp >= SMOOTHLEN) wp = 0;
        average.wp = wp;
        if (average.n == SMOOTHLEN) {
            // detect power peak
            double p = average.sum / static_cast<double>(SMOOTHLEN);
            if (p > average.max) average.max = p;
        } else {
            average.n++;
        }
    }
//     qDebug("%p -> pos=%llu, max=%g", this, reader->pos(), average.max);
}

Here is the call graph for this function:

Here is the caller graph for this function:

run()

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

virtual

normalizes the volume

Parameters

params

list of strings with parameters

Reimplemented from Kwave::Plugin.

Definition at line 68 of file NormalizePlugin.cpp.

References Kwave::connect(), Kwave::MultiTrackReader::eof(), Kwave::MultiWriter::flush(), getMaxPower(), Kwave::MultiTrackSource< SOURCE, INITIALIZE >::goOn(), Kwave::Overwrite, Kwave::Plugin::selection(), Kwave::Plugin::setProgressText(), Kwave::Plugin::shouldStop(), Kwave::Plugin::signalManager(), Kwave::SinglePassForward, TARGET_LEVEL, Kwave::MultiTrackSink< SINK, INITIALIZE >::tracks(), and Kwave::Plugin::updateProgress().

{
    Q_UNUSED(params);
    Kwave::UndoTransactionGuard undo_guard(*this, i18n("Normalize"));

    // get the current selection
    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;

    // get the current volume level
    double level = 0.0;
    {
        Kwave::MultiTrackReader src(Kwave::SinglePassForward,
            signalManager(), tracks, first, last);

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

        // detect the peak value
        emit setProgressText(i18n("Analyzing volume level..."));
//         qDebug("NormalizePlugin: getting peak...");
        level = getMaxPower(src);
//         qDebug("NormalizePlugin: level is %g", level);
    }

    Kwave::MultiTrackReader source(Kwave::SinglePassForward,
        signalManager(), tracks, first, last);
    Kwave::MultiTrackWriter sink(signalManager(), tracks, Kwave::Overwrite,
        first, last);
    Kwave::MultiTrackSource<Kwave::Normalizer, true> normalizer(
        tracks.count(), this);

    // break if aborted
    if (!sink.tracks()) return;

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

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

    double target = pow(10.0, (TARGET_LEVEL / 20.0));
    double gain = target / level;
    qDebug("NormalizePlugin: gain=%g", gain);

    QString db;
    emit setProgressText(i18n("Normalizing (%1 dB) ...",
        db.sprintf("%+0.1f", 20 * log10(gain))));

    normalizer.setAttribute(SLOT(setGain(QVariant)), QVariant(gain));
    while (!shouldStop() && !source.eof()) {
        source.goOn();
    }

    sink.flush();
}

Here is the call graph for this function:

---

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

• plugins/normalize/NormalizePlugin.h
• plugins/normalize/NormalizePlugin.cpp