alc/effects/compressor.cpp

   1 /**
   2  * This file is part of the OpenAL Soft cross platform audio library
   3  *
   4  * Copyright (C) 2013 by Anis A. Hireche
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * * Redistributions of source code must retain the above copyright notice,
  10  *   this list of conditions and the following disclaimer.
  11  *
  12  * * Redistributions in binary form must reproduce the above copyright notice,
  13  *   this list of conditions and the following disclaimer in the documentation
  14  *   and/or other materials provided with the distribution.
  15  *
  16  * * Neither the name of Spherical-Harmonic-Transform nor the names of its
  17  *   contributors may be used to endorse or promote products derived from
  18  *   this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "config.h"
  34
  35 #include <algorithm>
  36 #include <array>
  37 #include <cmath>
  38 #include <cstdlib>
  39 #include <variant>
  40
  41 #include "alc/effects/base.h"
  42 #include "alspan.h"
  43 #include "core/ambidefs.h"
  44 #include "core/bufferline.h"
  45 #include "core/device.h"
  46 #include "core/effects/base.h"
  47 #include "core/effectslot.h"
  48 #include "core/mixer/defs.h"
  49 #include "intrusive_ptr.h"
  50
  51 struct BufferStorage;
  52 struct ContextBase;
  53
  54
  55 namespace {
  56
  57 constexpr float AmpEnvelopeMin{0.5f};
  58 constexpr float AmpEnvelopeMax{2.0f};
  59
  60 constexpr float AttackTime{0.1f}; /* 100ms to rise from min to max */
  61 constexpr float ReleaseTime{0.2f}; /* 200ms to drop from max to min */
  62
  63
  64 struct CompressorState final : public EffectState {
  65     /* Effect gains for each channel */
  66     struct TargetGain {
  67         uint mTarget{InvalidChannelIndex};
  68         float mGain{1.0f};
  69     };
  70     std::array<TargetGain,MaxAmbiChannels> mChans;
  71
  72     /* Effect parameters */
  73     bool mEnabled{true};
  74     float mAttackMult{1.0f};
  75     float mReleaseMult{1.0f};
  76     float mEnvFollower{1.0f};
  77     alignas(16) FloatBufferLine mGains{};
  78
  79
  80     void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
  81     void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
  82         const EffectTarget target) override;
  83     void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
  84         const al::span<FloatBufferLine> samplesOut) override;
  85 };
  86
  87 void CompressorState::deviceUpdate(const DeviceBase *device, const BufferStorage*)
  88 {
  89     /* Number of samples to do a full attack and release (non-integer sample
  90      * counts are okay).
  91      */
  92     const float attackCount{static_cast<float>(device->Frequency) * AttackTime};
  93     const float releaseCount{static_cast<float>(device->Frequency) * ReleaseTime};
  94
  95     /* Calculate per-sample multipliers to attack and release at the desired
  96      * rates.
  97      */
  98     mAttackMult  = std::pow(AmpEnvelopeMax/AmpEnvelopeMin, 1.0f/attackCount);
  99     mReleaseMult = std::pow(AmpEnvelopeMin/AmpEnvelopeMax, 1.0f/releaseCount);
 100 }
 101
 102 void CompressorState::update(const ContextBase*, const EffectSlot *slot,
 103     const EffectProps *props, const EffectTarget target)
 104 {
 105     mEnabled = std::get<CompressorProps>(*props).OnOff;
 106
 107     mOutTarget = target.Main->Buffer;
 108     auto set_channel = [this](size_t idx, uint outchan, float outgain)
 109     {
 110         mChans[idx].mTarget = outchan;
 111         mChans[idx].mGain = outgain;
 112     };
 113     target.Main->setAmbiMixParams(slot->Wet, slot->Gain, set_channel);
 114 }
 115
 116 void CompressorState::process(const size_t samplesToDo,
 117     const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 118 {
 119     /* Generate the per-sample gains from the signal envelope. */
 120     float env{mEnvFollower};
 121     if(mEnabled)
 122     {
 123         for(size_t i{0u};i < samplesToDo;++i)
 124         {
 125             /* Clamp the absolute amplitude to the defined envelope limits,
 126              * then attack or release the envelope to reach it.
 127              */
 128             const float amplitude{std::clamp(std::fabs(samplesIn[0][i]), AmpEnvelopeMin,
 129                 AmpEnvelopeMax)};
 130             if(amplitude > env)
 131                 env = std::min(env*mAttackMult, amplitude);
 132             else if(amplitude < env)
 133                 env = std::max(env*mReleaseMult, amplitude);
 134
 135             /* Apply the reciprocal of the envelope to normalize the volume
 136              * (compress the dynamic range).
 137              */
 138             mGains[i] = 1.0f / env;
 139         }
 140     }
 141     else
 142     {
 143         /* Same as above, except the amplitude is forced to 1. This helps
 144          * ensure smooth gain changes when the compressor is turned on and off.
 145          */
 146         for(size_t i{0u};i < samplesToDo;++i)
 147         {
 148             const float amplitude{1.0f};
 149             if(amplitude > env)
 150                 env = std::min(env*mAttackMult, amplitude);
 151             else if(amplitude < env)
 152                 env = std::max(env*mReleaseMult, amplitude);
 153
 154             mGains[i] = 1.0f / env;
 155         }
 156     }
 157     mEnvFollower = env;
 158
 159     /* Now compress the signal amplitude to output. */
 160     auto chan = mChans.cbegin();
 161     for(const auto &input : samplesIn)
 162     {
 163         const size_t outidx{chan->mTarget};
 164         if(outidx != InvalidChannelIndex)
 165         {
 166             const auto dst = al::span{samplesOut[outidx]};
 167             const float gain{chan->mGain};
 168             if(!(std::fabs(gain) > GainSilenceThreshold))
 169             {
 170                 for(size_t i{0u};i < samplesToDo;++i)
 171                     dst[i] += input[i] * mGains[i] * gain;
 172             }
 173         }
 174         ++chan;
 175     }
 176 }
 177
 178
 179 struct CompressorStateFactory final : public EffectStateFactory {
 180     al::intrusive_ptr<EffectState> create() override
 181     { return al::intrusive_ptr<EffectState>{new CompressorState{}}; }
 182 };
 183
 184 } // namespace
 185
 186 EffectStateFactory *CompressorStateFactory_getFactory()
 187 {
 188     static CompressorStateFactory CompressorFactory{};
 189     return &CompressorFactory;
 190 }