Beatmup::Audio::Signal::Meter Class Reference

Signal dynamics meter. More...

#include <signal.h>

Inheritance diagram for Beatmup::Audio::Signal::Meter:

Public Types
enum class	MeasuringMode { preciseUsingSamples , approximateUsingLookup , preciseUsingLookupAndSamples }
	Specifies how to compute signal dynamics (minima and maxima in a given period of time) More...

Public Member Functions
	Meter (Signal &signal, dtime time, MeasuringMode mode=MeasuringMode::approximateUsingLookup)
	Constructs a new meter. More...
template<typename sample >
void	measure (dtime len, int resolution, sample min[], sample max[])
	Measures signal dynamics in a given period of time. More...
void	setMode (MeasuringMode newMode)
template<>
void	measure (dtime len, int resolution, sample16 min[], sample16 max[])
Public Member Functions inherited from Beatmup::Audio::Signal::Pointer
	Pointer (Signal &signal, dtime time, bool writing)
virtual void	releaseBuffer ()
unsigned char	getChannelCount () const

Static Public Member Functions
static void	prepareSignal (Signal &signal, bool runTask=true)
	Precomputes the dynamics lookup all over the signal, where needed. More...

Private Member Functions
template<typename sample >
void	measureInFragments (dtime len, int resolution, sample *min, sample *max)
	Measures signal dynamics in a given period of time. More...

Static Private Member Functions
static void	prepare (Signal &signal, int skipOnStart=0, int numSteps=1)

Private Attributes
MeasuringMode	mode

Detailed Description

Signal dynamics meter.

Definition at line 71 of file signal.h.

Member Enumeration Documentation

MeasuringMode

enum Beatmup::Audio::Signal::Meter::MeasuringMode

strong

Specifies how to compute signal dynamics (minima and maxima in a given period of time)

Enumerator
preciseUsingSamples	Just run across all samples. This does not require neither precomputing nor extra memory, but slow as hell.
approximateUsingLookup	Find an approximated range using a lookup tree. It is guaranteed that the resulting approximated dynamic range covers the precise range. Very fast for less fragmented signals, does not hit the sample data in memory, but requires precomputing and increases the memory footprint.
preciseUsingLookupAndSamples	Use lookup and then precise the measurement using sample data. Generally fast, except highly fragmented signals. Requires precomputing and increases the memory footprint (same as approximateUsingLookup);

Definition at line 76 of file signal.h.

                                     {
                /**
                    Just run across all samples.
                    This does not require neither precomputing nor extra memory, but slow as hell.
                */
                preciseUsingSamples,
 
                /**
                    Find an approximated range using a lookup tree.
                    It is guaranteed that the resulting approximated dynamic range covers the precise range. Very fast for less
                    fragmented signals, does not hit the sample data in memory, but requires precomputing and increases the
                    memory footprint.
                */
                approximateUsingLookup,
 
                /**
                    Use lookup and then precise the measurement using sample data.
                    Generally fast, except highly fragmented signals. Requires precomputing and increases the memory footprint
                    (same as `approximateUsingLookup`);
                */
                preciseUsingLookupAndSamples
            };

Constructor & Destructor Documentation

Meter()

Signal::Meter::Meter	(	Signal &	signal,
		dtime	time,
		MeasuringMode	mode = MeasuringMode::approximateUsingLookup
	)

Constructs a new meter.

Parameters

signal	The signal to measure
time	Initial time to start measurements from
mode	Algorithm used to measure the signal dynamics

Definition at line 197 of file signal.cpp.

                                                                :
    Pointer(signal, time, false), mode(mode)
{}

Member Function Documentation

measureInFragments()

template<typename sample >

template void Signal::Meter::measureInFragments ( dtime  len, int  resolution, sample *  min, sample *  max  )

private

Measures signal dynamics in a given period of time.

Deals with the fragmentation. The sample type must be coherent to the actual sample format of the signal.

Parameters

len	Period length in samples
resolution	Number of output points
min	Channelwise multiplexed magnitude minima, (resolution) points per channel
max	Channelwise multiplexed magnitude maxima, (resolution) points per channel

Definition at line 227 of file signal.cpp.

                                                                                                                  {
    const int channelCount = ((SignalFragment*)pointer.fragment)->getChannelCount();
    const dtime startTime = getTime();
    dtime t1 = startTime;
    sample *pMin = min, *pMax = max;
 
    // for all bins
    for (int bin = 1; bin <= resolution; bin++) {
        // determining bin bounds
        dtime t0 = t1;
        t1 = startTime + (long long)len * bin / resolution;
 
        // determining start time within fragment
        dtime fragStart = t0 - getTime() + pointer.offset;
 
        // initializing min and max values
        for (int ch = 0; ch < channelCount; ch++) {
            pMin[ch].x = sample::MAX_VALUE;
            pMax[ch].x = sample::MIN_VALUE;
        }
 
        // scanning fragments
        while (getTime() + pointer.length < t1) {
            ((SignalFragment*)pointer.fragment)->measureDynamics(fragStart, pointer.offset + pointer.length, pMin, pMax, mode);
            step();
            fragStart = pointer.offset;
        }
        ((SignalFragment*)pointer.fragment)->measureDynamics(fragStart, pointer.offset + t1 - getTime(), pMin, pMax, mode);
 
        // if no values defined
        for (int ch = 0; ch < channelCount; ch++)
            if (pMax[ch] < pMin[ch])
                pMin[ch].x = pMax[ch].x = 0;
        pMin += channelCount;
        pMax += channelCount;
    }
}

prepare()

void Signal::Meter::prepare ( Signal &  signal, int  skipOnStart = 0, int  numSteps = 1  )

staticprivate

Definition at line 183 of file signal.cpp.

                                                                       {
    Meter me(signal, 0, MeasuringMode::approximateUsingLookup);
    for (int skip = 0; skip < skipOnStart; skip++)
        me.step();
    while (me.hasData()) {
        SignalFragment* fragment = (SignalFragment*)me.pointer.fragment;
        if (fragment && !fragment->isDynamicsLookupAvailable())
            fragment->updateDynamicsLookup();
        for (int skip = 0; skip < numSteps; skip++)
            me.step();
    }
}

prepareSignal()

void Signal::Meter::prepareSignal ( Signal &  signal, bool  runTask = true  )

static

Precomputes the dynamics lookup all over the signal, where needed.

Parameters

signal	The signal to process
runTask	If true, a task will be run in the context of the signal allowing to process it in parallel; otherwise the computation is done directly in the calling thread

Definition at line 202 of file signal.cpp.

                                                            {
    if (runTask) {
 
        class DynamicsLookupPreparation : public AbstractTask {
        public:
            Signal& signal;
            bool process(TaskThread& thread) {
                // interleaving fragments among threads
                Meter::prepare(signal, thread.currentThread(), thread.numThreads());
                return true;
            }
 
            TaskDeviceRequirement getExecutionMode() const { return AbstractTask::TaskDeviceRequirement::CPU_ONLY; }
            ThreadIndex getMaxThreads() const { return MAX_THREAD_INDEX; }
            DynamicsLookupPreparation(Signal& signal) : signal(signal) {}
        };
 
        DynamicsLookupPreparation task(signal);
        signal.getContext().performTask(task);
    }
    else
        Meter::prepare(signal);
}

measure() [1/2]

template<typename sample >

void Beatmup::Audio::Signal::Meter::measure	(	dtime	len,
		int	resolution,
		sample	min[],
		sample	max[]
	)

Measures signal dynamics in a given period of time.

Parameters

len	Period length in samples
resolution	Number of output points
min	Channelwise multiplexed magnitude minima, (resolution) points per channel
max	Channelwise multiplexed magnitude maxima, (resolution) points per channel

setMode()

void Beatmup::Audio::Signal::Meter::setMode ( MeasuringMode  newMode )

inline

Definition at line 140 of file signal.h.

{ mode = newMode; }

measure() [2/2]

template<>

void Beatmup::Audio::Signal::Meter::measure	(	dtime	len,
		int	resolution,
		sample16	min[],
		sample16	max[]
	)

Definition at line 273 of file signal.cpp.

                                                                                                  {
        const AudioSampleFormat fmt = ((SignalFragment*)pointer.fragment)->getAudioFormat();
        if (fmt == Int16) {
            measureInFragments(len, resolution, (sample16*)min, (sample16*)max);
            return;
        }
        // converting min/max types
        const int size = resolution * ((SignalFragment*)pointer.fragment)->getChannelCount();
        switch (fmt) {
        case Int8: {
            sample8 *tmin = new sample8[size], *tmax = new sample8[size];
            measureInFragments(len, resolution, tmin, tmax);
            convertSamples<sample8, sample16>(tmin, min, resolution);
            convertSamples<sample8, sample16>(tmax, max, resolution);
            delete[] tmin;
            delete[] tmax;
            break;
        }
        case Int32: {
            sample32 *tmin = new sample32[size], *tmax = new sample32[size];
            measureInFragments(len, resolution, tmin, tmax);
            convertSamples<sample32, sample16>(tmin, min, resolution);
            convertSamples<sample32, sample16>(tmax, max, resolution);
            delete[] tmin;
            delete[] tmax;
            break;
        }
        case Float32: {
            sample32f *tmin = new sample32f[size], *tmax = new sample32f[size];
            measureInFragments(len, resolution, tmin, tmax);
            convertSamples<sample32f, sample16>(tmin, min, resolution);
            convertSamples<sample32f, sample16>(tmax, max, resolution);
            delete[] tmin;
            delete[] tmax;
            break;
        }
        default:
            Insanity::insanity("Unknown audio format");
        }
    }

Member Data Documentation

mode

MeasuringMode Beatmup::Audio::Signal::Meter::mode

private

Definition at line 112 of file signal.h.

---

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

• core/audio/signal.h
• core/audio/signal.cpp