alc/effects/echo.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2009 by Chris Robinson.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <algorithm>
  24 #include <array>
  25 #include <cmath>
  26 #include <cstdlib>
  27 #include <variant>
  28 #include <vector>
  29
  30 #include "alc/effects/base.h"
  31 #include "alnumeric.h"
  32 #include "alspan.h"
  33 #include "core/ambidefs.h"
  34 #include "core/bufferline.h"
  35 #include "core/context.h"
  36 #include "core/device.h"
  37 #include "core/effects/base.h"
  38 #include "core/effectslot.h"
  39 #include "core/filters/biquad.h"
  40 #include "core/mixer.h"
  41 #include "intrusive_ptr.h"
  42 #include "opthelpers.h"
  43
  44 struct BufferStorage;
  45
  46 namespace {
  47
  48 using uint = unsigned int;
  49
  50 constexpr float LowpassFreqRef{5000.0f};
  51
  52 struct EchoState final : public EffectState {
  53     std::vector<float> mSampleBuffer;
  54
  55     // The echo is two tap. The delay is the number of samples from before the
  56     // current offset
  57     std::array<size_t,2> mDelayTap{};
  58     size_t mOffset{0u};
  59
  60     /* The panning gains for the two taps */
  61     struct OutGains {
  62         std::array<float,MaxAmbiChannels> Current{};
  63         std::array<float,MaxAmbiChannels> Target{};
  64     };
  65     std::array<OutGains,2> mGains;
  66
  67     BiquadFilter mFilter;
  68     float mFeedGain{0.0f};
  69
  70     alignas(16) std::array<FloatBufferLine,2> mTempBuffer{};
  71
  72     void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
  73     void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
  74         const EffectTarget target) override;
  75     void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
  76         const al::span<FloatBufferLine> samplesOut) override;
  77 };
  78
  79 void EchoState::deviceUpdate(const DeviceBase *Device, const BufferStorage*)
  80 {
  81     const auto frequency = static_cast<float>(Device->Frequency);
  82
  83     // Use the next power of 2 for the buffer length, so the tap offsets can be
  84     // wrapped using a mask instead of a modulo
  85     const uint maxlen{NextPowerOf2(float2uint(EchoMaxDelay*frequency + 0.5f) +
  86         float2uint(EchoMaxLRDelay*frequency + 0.5f))};
  87     if(maxlen != mSampleBuffer.size())
  88         decltype(mSampleBuffer)(maxlen).swap(mSampleBuffer);
  89
  90     std::fill(mSampleBuffer.begin(), mSampleBuffer.end(), 0.0f);
  91     for(auto &e : mGains)
  92     {
  93         std::fill(e.Current.begin(), e.Current.end(), 0.0f);
  94         std::fill(e.Target.begin(), e.Target.end(), 0.0f);
  95     }
  96 }
  97
  98 void EchoState::update(const ContextBase *context, const EffectSlot *slot,
  99     const EffectProps *props_, const EffectTarget target)
 100 {
 101     auto &props = std::get<EchoProps>(*props_);
 102     const DeviceBase *device{context->mDevice};
 103     const auto frequency = static_cast<float>(device->Frequency);
 104
 105     mDelayTap[0] = std::max(float2uint(std::round(props.Delay*frequency)), 1u);
 106     mDelayTap[1] = float2uint(std::round(props.LRDelay*frequency)) + mDelayTap[0];
 107
 108     const float gainhf{std::max(1.0f - props.Damping, 0.0625f)}; /* Limit -24dB */
 109     mFilter.setParamsFromSlope(BiquadType::HighShelf, LowpassFreqRef/frequency, gainhf, 1.0f);
 110
 111     mFeedGain = props.Feedback;
 112
 113     /* Convert echo spread (where 0 = center, +/-1 = sides) to a 2D vector. */
 114     const float x{props.Spread}; /* +x = left */
 115     const float z{std::sqrt(1.0f - x*x)};
 116
 117     const auto coeffs0 = CalcAmbiCoeffs( x, 0.0f, z, 0.0f);
 118     const auto coeffs1 = CalcAmbiCoeffs(-x, 0.0f, z, 0.0f);
 119
 120     mOutTarget = target.Main->Buffer;
 121     ComputePanGains(target.Main, coeffs0, slot->Gain, mGains[0].Target);
 122     ComputePanGains(target.Main, coeffs1, slot->Gain, mGains[1].Target);
 123 }
 124
 125 void EchoState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 126 {
 127     const auto delaybuf = al::span{mSampleBuffer};
 128     const size_t mask{delaybuf.size()-1};
 129     size_t offset{mOffset};
 130     size_t tap1{offset - mDelayTap[0]};
 131     size_t tap2{offset - mDelayTap[1]};
 132
 133     ASSUME(samplesToDo > 0);
 134
 135     const BiquadFilter filter{mFilter};
 136     auto [z1, z2] = mFilter.getComponents();
 137     for(size_t i{0u};i < samplesToDo;)
 138     {
 139         offset &= mask;
 140         tap1 &= mask;
 141         tap2 &= mask;
 142
 143         size_t td{std::min(mask+1 - std::max(offset, std::max(tap1, tap2)), samplesToDo-i)};
 144         do {
 145             /* Feed the delay buffer's input first. */
 146             delaybuf[offset] = samplesIn[0][i];
 147
 148             /* Get delayed output from the first and second taps. Use the
 149              * second tap for feedback.
 150              */
 151             mTempBuffer[0][i] = delaybuf[tap1++];
 152             mTempBuffer[1][i] = delaybuf[tap2++];
 153             const float feedb{mTempBuffer[1][i++]};
 154
 155             /* Add feedback to the delay buffer with damping and attenuation. */
 156             delaybuf[offset++] += filter.processOne(feedb, z1, z2) * mFeedGain;
 157         } while(--td);
 158     }
 159     mFilter.setComponents(z1, z2);
 160     mOffset = offset;
 161
 162     for(size_t c{0};c < 2;c++)
 163         MixSamples(al::span{mTempBuffer[c]}.first(samplesToDo), samplesOut, mGains[c].Current,
 164             mGains[c].Target, samplesToDo, 0);
 165 }
 166
 167
 168 struct EchoStateFactory final : public EffectStateFactory {
 169     al::intrusive_ptr<EffectState> create() override
 170     { return al::intrusive_ptr<EffectState>{new EchoState{}}; }
 171 };
 172
 173 } // namespace
 174
 175 EffectStateFactory *EchoStateFactory_getFactory()
 176 {
 177     static EchoStateFactory EchoFactory{};
 178     return &EchoFactory;
 179 }