Beatmup::Audio::SignalFragment::DynamicsLookup Class Reference

Data structure allowing to plot efficiently audio signal graphs. More...

Public Member Functions
	DynamicsLookup ()
	~DynamicsLookup ()
void	disposeTree ()
	Frees the current level and all previous. More...
void	configureTree (unsigned char channelCount, int levelCount, int fineStepSize, int coarserStepSize)
	Sets up the tree structure. More...
template<typename sample >
void	updateTree (const sample *data, int sampleCount)
	Updates tree from raw sample data. More...
template<typename sample >
void	measure (dtime time0, dtime time1, sample *min, sample *max, const void *data) const
	Measures dynamics from time0 to time1 in each channels separately. More...
bool	isReady () const

Private Member Functions
	DynamicsLookup (const DynamicsLookup &)=delete
	disabling copying constructor More...

Private Attributes
DynamicsLookup *	prev
	previous (finer scale) level More...
void *	minmax
	(2*size) points per channel, channel-wise multiplexed, interleaved minima and maxima More...
unsigned char	channelCount
int	size
	buffer size in points in one channel, i.e., size in bytes is 2*channelCount*sizeof(magnitude)*size More...
int	step
	step (block) size in points w.r.t. previous layer (points = samples if there's no previous layer) More...
int	stepTime
	step (block) size in absolute time units More...

Detailed Description

Data structure allowing to plot efficiently audio signal graphs.

Definition at line 44 of file signal_fragment.h.

Constructor & Destructor Documentation

DynamicsLookup() [1/2]

Beatmup::Audio::SignalFragment::DynamicsLookup::DynamicsLookup ( const DynamicsLookup &  )

privatedelete

disabling copying constructor

DynamicsLookup() [2/2]

Beatmup::Audio::SignalFragment::DynamicsLookup::DynamicsLookup ( )

inline

Definition at line 56 of file signal_fragment.h.

: prev(nullptr), minmax(nullptr), channelCount(0), size(0), step(0), stepTime(0) {}

~DynamicsLookup()

SignalFragment::DynamicsLookup::~DynamicsLookup

(

)

Definition at line 235 of file signal_fragment.cpp.

                                              {
    disposeTree();
}

Member Function Documentation

disposeTree()

void SignalFragment::DynamicsLookup::disposeTree

(

)

Frees the current level and all previous.

Definition at line 53 of file signal_fragment.cpp.

                                               {
    if (prev) {
        delete prev;
        prev = nullptr;
    }
    if (minmax)
        free(minmax);
    size = 0;
}

configureTree()

void SignalFragment::DynamicsLookup::configureTree	(	unsigned char	channelCount,
		int	levelCount,
		int	fineStepSize,
		int	coarserStepSize
	)

Sets up the tree structure.

Parameters

channelCount	Number of channels
levelCount	Number of detail levels
fineStepSize	The most detailed level step size in samples
coarserStepSize	Size of step in points for every upper (less detailed) level

Definition at line 64 of file signal_fragment.cpp.

                                                                                                                                  {
    this->channelCount = channelCount;
    if (levelCount == 1) {
        // fine level
        if (prev)
            delete prev;
        stepTime = step = fineStepSize;
        prev = nullptr;
    }
    else if (levelCount > 0) {
        if (!prev)
            prev = new DynamicsLookup();
        step = coarserStepSize;
        prev->configureTree(channelCount, levelCount - 1, fineStepSize, coarserStepSize);
        stepTime = step * prev->stepTime;
    }
}

updateTree()

template<typename sample >

template void SignalFragment::DynamicsLookup::updateTree ( const sample *  data, int  sampleCount  )

inline

Updates tree from raw sample data.

Parameters

data	Pointer to the input data
sampleCount	Number of samples pointed by the data in each channel

Definition at line 83 of file signal_fragment.cpp.

                                                                                                                  {
    // if there is a finer scale ...
    if (prev) {
        // ... send sample data to it recursively
        prev->updateTree(data, sampleCount);
        // update the current level: reallocate table first
        int newSize = ceili(prev->size, step);
        if (newSize != size) {
            minmax = realloc(minmax, newSize * 2 * channelCount * sizeof(sample));
            size = newSize;
        }
        // fill it then
        sample *out = (sample*)minmax;
        const int skip = 2 * channelCount;
        for (int block = 0; block < prev->size; block += step) {
            const int blockSize = std::min(step, prev->size - block);
            // channel multiplexing
            for (int ch = 0; ch < channelCount; ch++) {
                sample *in = (sample*)prev->minmax + block * skip + 2 * ch, *stop = in + blockSize * skip;
                sample vMin = in[0], vMax = in[1];
                in += skip;
                while (in < stop) {
                    vMin = std::min(vMin, in[0]);
                    vMax = std::max(vMax, in[1]);
                    in += skip;
                }
                *(out++) = vMin;
                *(out++) = vMax;
            }
        }
    }
    // update finest scale level: reallocate table first
    else {
        int newSize = ceili(sampleCount, step);
        if (newSize != size) {
            minmax = realloc(minmax, newSize * 2 * channelCount * sizeof(sample));
            size = newSize;
        }
        // fill it then
        sample *out = (sample*)minmax;
        for (int time = 0; time < sampleCount; time += step) {
            const int blockSize = std::min(step, sampleCount - time);
            const sample *start = data + time * channelCount, *stop = start + blockSize * channelCount;
            // channel demultiplexing
            for (int ch = 0; ch < channelCount; ch++) {
                sample min{ sample::MAX_VALUE }, max{ sample::MIN_VALUE };
                measureMultiplexedChannelDynamics(start + ch, stop + ch, channelCount, min, max);
                out[0] = min;
                out[1] = max;
                out += 2;
            }
        }
    }
}

measure()

template<typename sample >

template void SignalFragment::DynamicsLookup::measure	(	dtime	time0,
		dtime	time1,
		sample *	min,
		sample *	max,
		const void *	data
	)		const

Measures dynamics from time0 to time1 in each channels separately.

Parameters

time0	Start time
time1	Stop time
min	Channelwise multiplexed minima
max	Channelwise multiplexed maxima
data	Channelwise multiplexed sample data for a more precise measurement; may be null

Definition at line 144 of file signal_fragment.cpp.

                                                                                                                                               {
    int b0, b1;         // bounding block indices
    // if there is a finer level, take the inset and ask for the remaining parts this finer level
    if (prev) {
        b0 = ceili(time0, stepTime);
        b1 = time1 / stepTime;
        dtime
            t0 = b0 * stepTime,
            t1 = b1 * stepTime;
        if (t0 >= t1) {
            // this level is too coarse
            prev->measure<sample>(time0, time1, min, max, data);
            return;
        }
 
        if (time0 < t0)
            prev->measure<sample>(time0, t0, min, max, data);
        if (t1 < time1)
            prev->measure<sample>(t1, time1, min, max, data);
    }
 
    // if not, but if there is some sample data, take an inset and measure leftovers using the sample data
    else if (data) {
        b0 = ceili(time0, stepTime);
        b1 = time1 / stepTime;
        // if there are some blocks (more than one)
        if (b0 < b1) {
            dtime
                t0 = b0 * stepTime,
                t1 = b1 * stepTime;
            if (time0 < t0 || t1 < time1) {
                sample *pMin = min, *pMax = max;
                for (int ch = 0; ch < channelCount; ch++, pMin++, pMax++) {
                    if (time0 < t0)
                        measureMultiplexedChannelDynamics(
                            (sample*)data + time0 * channelCount + ch,
                            (sample*)data + t0 * channelCount + ch,
                            channelCount,
                            *pMin, *pMax
                        );
                    if (t1 < time1)
                        measureMultiplexedChannelDynamics(
                            (sample*)data + t1 * channelCount + ch,
                            (sample*)data + time1 * channelCount + ch,
                            channelCount,
                            *pMin, *pMax
                        );
                }
            }
        }
        // the time borders are both within the same block
        else {
            for (int ch = 0; ch < channelCount; ch++, min++, max++)
                measureMultiplexedChannelDynamics(
                    (sample*)data + time0 * channelCount + ch,
                    (sample*)data + time1 * channelCount + ch,
                    channelCount,
                    *min, *max
                );
            return;
        }
    }
 
    // otherwise take the outset
    else {
        b0 = time0 / stepTime;
        b1 = std::max(b0+1, ceili(time1, stepTime));
    }
 
    BEATMUP_ASSERT_DEBUG(b1 <= size);
 
    // scan selected block set
    const int skip = 2 * channelCount;
    for (int chSkip = 0; chSkip < skip; chSkip += 2) {
        sample *ptr = (sample*)minmax + skip*b0 + chSkip, *stop = (sample*)minmax + skip*b1 + chSkip;
        while (ptr < stop) {
            min->x = std::min(ptr[0].x, min->x);
            max->x = std::max(ptr[1].x, max->x);
            ptr += skip;
        }
        min++;
        max++;
    }
}

isReady()

bool Beatmup::Audio::SignalFragment::DynamicsLookup::isReady ( ) const

inline

Definition at line 93 of file signal_fragment.h.

{ return minmax != NULL; }

Member Data Documentation

prev

DynamicsLookup* Beatmup::Audio::SignalFragment::DynamicsLookup::prev

private

previous (finer scale) level

Definition at line 46 of file signal_fragment.h.

minmax

void* Beatmup::Audio::SignalFragment::DynamicsLookup::minmax

private

(2*size) points per channel, channel-wise multiplexed, interleaved minima and maxima

Definition at line 47 of file signal_fragment.h.

channelCount

unsigned char Beatmup::Audio::SignalFragment::DynamicsLookup::channelCount

private

Definition at line 48 of file signal_fragment.h.

size

int Beatmup::Audio::SignalFragment::DynamicsLookup::size

private

buffer size in points in one channel, i.e., size in bytes is 2*channelCount*sizeof(magnitude)*size

Definition at line 49 of file signal_fragment.h.

step

int Beatmup::Audio::SignalFragment::DynamicsLookup::step

private

step (block) size in points w.r.t. previous layer (points = samples if there's no previous layer)

Definition at line 50 of file signal_fragment.h.

stepTime

int Beatmup::Audio::SignalFragment::DynamicsLookup::stepTime

private

step (block) size in absolute time units

Definition at line 51 of file signal_fragment.h.

---

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

• core/audio/signal_fragment.h
• core/audio/signal_fragment.cpp