Method Echo

examples/sound_effects/SoundEffects.cpp:860–913

struct Echo : Processing
{
    Echo() : Processing("Echo")
    {
        auto& music = getMusic();

        static constexpr auto delay = 0.2f;
        static constexpr auto decay = 0.75f;
        static constexpr auto wet   = 0.8f;
        static constexpr auto dry   = 1.f;

        const auto sampleRate    = sf::PlaybackDevice::getDeviceSampleRate().value_or(44100);
        const auto delayInFrames = static_cast<unsigned int>(static_cast<float>(sampleRate) * delay);

        // We use a mutable lambda to tie the lifetime of the state to the lambda itself
        // This is necessary since the Echo object will be destroyed before the Music object
        // While the Music object exists, it is possible that the audio engine will try to call
        // this lambda hence we need to always have a usable state until the Music and the
        // associated lambda are destroyed
        music.setEffectProcessor(
            [delayInFrames,
             enabled = getEnabled(),
             buffer  = std::vector<float>(),
             cursor  = 0u](const float*  inputFrames,
                          unsigned int& inputFrameCount,
                          float*        outputFrames,
                          unsigned int& outputFrameCount,
                          unsigned int  frameChannelCount) mutable
            {
                // IMPORTANT: The channel count of the audio engine currently sourcing data from this sound
                // will always be provided in frameChannelCount, this can be different from the channel count
                // of the audio source so make sure to size your buffers according to the engine and not the source
                // Ensure we have enough space to store the delayed frames for all of the audio engine's channels
                if (buffer.size() < delayInFrames * frameChannelCount)
                    buffer.resize(delayInFrames * frameChannelCount - buffer.size(), 0.f);

                for (auto frame = 0u; frame < outputFrameCount; ++frame)
                {
                    for (auto channel = 0u; channel < frameChannelCount; ++channel)
                    {
                        const auto input = inputFrames ? inputFrames[channel] : 0.f; // Read silence if no input data available
                        const auto bufferIndex = (cursor * frameChannelCount) + channel;
                        buffer[bufferIndex]    = (buffer[bufferIndex] * decay) + (input * dry);
                        outputFrames[channel]  = *enabled ? buffer[bufferIndex] * wet : input;
                    }

                    cursor = (cursor + 1) % delayInFrames;

                    inputFrames += (inputFrames ? frameChannelCount : 0u);
                    outputFrames += frameChannelCount;
                }

                // We processed data 1:1
                inputFrameCount = outputFrameCount;
            });
    }
};