vae::core::Processor Class Reference

Non spatial voice processor. More...

#include <vae_processor.hpp>

Collaboration diagram for vae::core::Processor:

Public Member Functions
Result	init ()
Size	mix (VoiceManger &manager, Bank &bank, SampleIndex frames, Size sampleRate)
	Process a single bank. More...

Private Attributes
ScratchBuffer	mScratchBuffer
	Temporary filtered/looped signal TODO this will not work with parallel bank processing. More...

Detailed Description

Non spatial voice processor.

Definition at line 18 of file vae_processor.hpp.

Member Function Documentation

init()

Result vae::core::Processor::init ( )

inline

Definition at line 24 of file vae_processor.hpp.

                      {
            mScratchBuffer.resize(StaticConfig::MaxBlock, StaticConfig::MaxChannels);
            return Result::Success;
        }

Here is the call graph for this function:

mix()

Size vae::core::Processor::mix ( VoiceManger &  manager, Bank &  bank, SampleIndex  frames, Size  sampleRate  )

inline

Process a single bank.

Parameters

manager
banks
frames
sampleRate

Returns

Voices renderd

Definition at line 38 of file vae_processor.hpp.

          {
            Size actuallyRendered = 0;
            VAE_PROFILER_SCOPE_NAMED("Default Processor")
            manager.forEachVoice([&](Voice& v, Size index) {
                if (v.bank != bank.id) { return true; }
                if (v.spatialized) { return true; }
                VAE_PROFILER_SCOPE_NAMED("Default Voice")
 
                auto& source = bank.sources[v.source];
                auto& signal = source.signal;
 
                const SampleIndex signalLength = signal.size();
 
                if (signalLength == 0) { return false; }
                if (signal.sampleRate != sampleRate) {
                    // VAE_DEBUG("Spatial Voice samplerate mismatch. Enabled filter.")
                    v.filtered = true; // implicitly filter to resample
                }
 
                v.time = v.time % signalLength;     // Keep signal in bounds before starting
 
                const auto signalChannels = signal.channels();
                auto& mixer = bank.mixers[v.mixer];
                auto& target = mixer.buffer;
                const auto targetChannels = target.channels();
                const auto gain = v.gain * source.gain;
 
                // TODO skip inaudible sounds
                actuallyRendered++;
                v.audible = true;
                auto& pan = manager.getVoicePan(index);
                target.setValidSize(frames); // mark mixer as active
 
                if (!v.filtered) {
                    VAE_PROFILER_SCOPE_NAMED("Render Voice Basic")
                    // Basic rendering to all output channels w/o any effects
                    v.started = true;
                    const SampleIndex needed = v.loop ? frames : std::min(frames, SampleIndex(signalLength - v.time));
 
                    if (v.loop) {
                        for (int c = 0; c < targetChannels; c++) {
                            const int channel = c % signalChannels;
                            for (SampleIndex s = 0; s < needed; s++) {
                                target[c][s] +=
                                    signal[channel][((v.time + s) % signalLength)] * gain * pan.volumes[c];
                            }
                        }
                    } else {
                        // Having these seperate results in like a 3x speedup
                        // TODO check this in a more diffictult to branchpredict scenario
                        for (int c = 0; c < targetChannels; c++) {
                            for (SampleIndex s = 0; s < needed; s++) {
                            const int channel = c % signalChannels;
                                target[c][s] +=
                                    signal[channel][v.time + s] * gain * pan.volumes[c];
                            }
                        }
                    }
 
                    v.time = v.time + frames;   // progress voice
                    return needed == frames;    // Finished if there are no samples left in source
                }
 
                // Filtered voice processing
                {
                    VAE_PROFILER_SCOPE_NAMED("Render filtered Voice")
                    auto& fd = manager.getVoiceFilter(index);
 
                    if (!v.started) {
                        // Initialize filter variables when first playing the voice
                        for (int c = 0; c < StaticConfig::MaxChannels; c++) {
                            fd.highpassScratch[c]   = 0;
                            fd.lowpassScratch[c]    = signal[c % signalChannels][v.time];
                        }
                        v.started = true;
                    }
 
                    // fractional time, we need the value after the loop, so it's defined outside
                    Real position;
 
                    // Playback speed taking samplerate into account
                    const Real speed = fd.speed * (Sample(signal.sampleRate) / Sample(sampleRate));
                    const SampleIndex needed = v.loop ? frames : std::min(
                        frames, SampleIndex(std::floor((signalLength - v.time) / speed - fd.timeFract))
                    );
 
                    for (int c = 0; c < target.channels(); c++) {
                        for (SampleIndex s = 0; s < needed; s++) {
                        const int channel = c % signal.channels();
                            // Linear interpolation between two samples
                            position = v.time + (s * speed) + fd.timeFract;
                            const Real lastPosition = std::floor(position);
                            const Size lastIndex = (Size) lastPosition;
                            const Size nextIndex = (Size) lastPosition + 1;
 
                            Real mix = position - lastPosition;
                            // mix = 0.5 * (1.0 - cos((mix) * 3.1416)); // cosine interpolation, introduces new harmonics somehow
                            const Sample last = signal[channel][lastIndex % signalLength] * gain;
                            const Sample next = signal[channel][nextIndex % signalLength] * gain;
                            // linear resampling, sounds alright enough
                            const Sample in = last + mix * (next - last);
 
                            //  * super simple lowpass and highpass filter
                            // just lerps with a previous value
                            const Sample lf = fd.lowpass;
                            const Sample lpd = in + lf * (fd.lowpassScratch[c] - in);
                            fd.lowpassScratch[c] = lpd;
 
                            const Sample hf = fd.highpass;
                            const Sample hps = fd.highpassScratch[c];
                            const Sample hpd = hps + hf * (in - hps);
                            fd.highpassScratch[c] = hpd;
 
                            target[c][s] += (lpd - hpd) * pan.volumes[c];
                        }
                    }
                    position += speed;                              // step to next sample
                    v.time = (SampleIndex) std::floor(position);    // split the signal in normal sample position
                    fd.timeFract = position - v.time;               // and fractional time for the next block
                    return needed == frames;                        // we might have reached the end;                   // is only true when exceeding signalLength and not looping
                }
            });
            return actuallyRendered;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mScratchBuffer

ScratchBuffer vae::core::Processor::mScratchBuffer

private

Temporary filtered/looped signal TODO this will not work with parallel bank processing.

Definition at line 22 of file vae_processor.hpp.

---

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

• vae_processor.hpp