juce/source/src/audio/dsp/juce_Reverb.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifndef __JUCE_REVERB_JUCEHEADER__
  27 #define __JUCE_REVERB_JUCEHEADER__
  28
  29
  30 //==============================================================================
  31 /**
  32     Performs a simple reverb effect on a stream of audio data.
  33
  34     This is a simple stereo reverb, based on the technique and tunings used in FreeVerb.
  35     Use setSampleRate() to prepare it, and then call processStereo() or processMono() to
  36     apply the reverb to your audio data.
  37
  38     @see ReverbAudioSource
  39 */
  40 class Reverb
  41 {
  42 public:
  43     //==============================================================================
  44     Reverb()
  45     {
  46         setParameters (Parameters());
  47         setSampleRate (44100.0);
  48     }
  49
  50     //==============================================================================
  51     /** Holds the parameters being used by a Reverb object. */
  52     struct Parameters
  53     {
  54         Parameters() noexcept
  55           : roomSize (0.5f),
  56             damping (0.5f),
  57             wetLevel (0.33f),
  58             dryLevel (0.4f),
  59             width (1.0f),
  60             freezeMode (0)
  61         {}
  62
  63         float roomSize;     /**< Room size, 0 to 1.0, where 1.0 is big, 0 is small. */
  64         float damping;      /**< Damping, 0 to 1.0, where 0 is not damped, 1.0 is fully damped. */
  65         float wetLevel;     /**< Wet level, 0 to 1.0 */
  66         float dryLevel;     /**< Dry level, 0 to 1.0 */
  67         float width;        /**< Reverb width, 0 to 1.0, where 1.0 is very wide. */
  68         float freezeMode;   /**< Freeze mode - values < 0.5 are "normal" mode, values > 0.5
  69                                  put the reverb into a continuous feedback loop. */
  70     };
  71
  72     //==============================================================================
  73     /** Returns the reverb's current parameters. */
  74     const Parameters& getParameters() const noexcept    { return parameters; }
  75
  76     /** Applies a new set of parameters to the reverb.
  77         Note that this doesn't attempt to lock the reverb, so if you call this in parallel with
  78         the process method, you may get artifacts.
  79     */
  80     void setParameters (const Parameters& newParams)
  81     {
  82         const float wetScaleFactor = 3.0f;
  83         const float dryScaleFactor = 2.0f;
  84
  85         const float wet = newParams.wetLevel * wetScaleFactor;
  86         wet1 = wet * (newParams.width * 0.5f + 0.5f);
  87         wet2 = wet * (1.0f - newParams.width) * 0.5f;
  88         dry = newParams.dryLevel * dryScaleFactor;
  89         gain = isFrozen (newParams.freezeMode) ? 0.0f : 0.015f;
  90         parameters = newParams;
  91         shouldUpdateDamping = true;
  92     }
  93
  94     //==============================================================================
  95     /** Sets the sample rate that will be used for the reverb.
  96         You must call this before the process methods, in order to tell it the correct sample rate.
  97     */
  98     void setSampleRate (const double sampleRate)
  99     {
 100         jassert (sampleRate > 0);
 101
 102         static const short combTunings[] = { 1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617 }; // (at 44100Hz)
 103         static const short allPassTunings[] = { 556, 441, 341, 225 };
 104         const int stereoSpread = 23;
 105         const int intSampleRate = (int) sampleRate;
 106
 107         int i;
 108         for (i = 0; i < numCombs; ++i)
 109         {
 110             comb[0][i].setSize ((intSampleRate * combTunings[i]) / 44100);
 111             comb[1][i].setSize ((intSampleRate * (combTunings[i] + stereoSpread)) / 44100);
 112         }
 113
 114         for (i = 0; i < numAllPasses; ++i)
 115         {
 116             allPass[0][i].setSize ((intSampleRate * allPassTunings[i]) / 44100);
 117             allPass[1][i].setSize ((intSampleRate * (allPassTunings[i] + stereoSpread)) / 44100);
 118         }
 119
 120         shouldUpdateDamping = true;
 121     }
 122
 123     /** Clears the reverb's buffers. */
 124     void reset()
 125     {
 126         for (int j = 0; j < numChannels; ++j)
 127         {
 128             int i;
 129             for (i = 0; i < numCombs; ++i)
 130                 comb[j][i].clear();
 131
 132             for (i = 0; i < numAllPasses; ++i)
 133                 allPass[j][i].clear();
 134         }
 135     }
 136
 137     //==============================================================================
 138     /** Applies the reverb to two stereo channels of audio data. */
 139     void processStereo (float* const left, float* const right, const int numSamples) noexcept
 140     {
 141         jassert (left != nullptr && right != nullptr);
 142
 143         if (shouldUpdateDamping)
 144             updateDamping();
 145
 146         for (int i = 0; i < numSamples; ++i)
 147         {
 148             const float input = (left[i] + right[i]) * gain;
 149             float outL = 0, outR = 0;
 150
 151             int j;
 152             for (j = 0; j < numCombs; ++j)  // accumulate the comb filters in parallel
 153             {
 154                 outL += comb[0][j].process (input);
 155                 outR += comb[1][j].process (input);
 156             }
 157
 158             for (j = 0; j < numAllPasses; ++j)  // run the allpass filters in series
 159             {
 160                 outL = allPass[0][j].process (outL);
 161                 outR = allPass[1][j].process (outR);
 162             }
 163
 164             left[i]  = outL * wet1 + outR * wet2 + left[i]  * dry;
 165             right[i] = outR * wet1 + outL * wet2 + right[i] * dry;
 166         }
 167     }
 168
 169     /** Applies the reverb to a single mono channel of audio data. */
 170     void processMono (float* const samples, const int numSamples) noexcept
 171     {
 172         jassert (samples != nullptr);
 173
 174         if (shouldUpdateDamping)
 175             updateDamping();
 176
 177         for (int i = 0; i < numSamples; ++i)
 178         {
 179             const float input = samples[i] * gain;
 180             float output = 0;
 181
 182             int j;
 183             for (j = 0; j < numCombs; ++j)  // accumulate the comb filters in parallel
 184                 output += comb[0][j].process (input);
 185
 186             for (j = 0; j < numAllPasses; ++j)  // run the allpass filters in series
 187                 output = allPass[0][j].process (output);
 188
 189             samples[i] = output * wet1 + input * dry;
 190         }
 191     }
 192
 193 private:
 194     //==============================================================================
 195     Parameters parameters;
 196
 197     volatile bool shouldUpdateDamping;
 198     float gain, wet1, wet2, dry;
 199
 200     inline static bool isFrozen (const float freezeMode) noexcept  { return freezeMode >= 0.5f; }
 201
 202     void updateDamping() noexcept
 203     {
 204         const float roomScaleFactor = 0.28f;
 205         const float roomOffset = 0.7f;
 206         const float dampScaleFactor = 0.4f;
 207
 208         shouldUpdateDamping = false;
 209
 210         if (isFrozen (parameters.freezeMode))
 211             setDamping (1.0f, 0.0f);
 212         else
 213             setDamping (parameters.damping * dampScaleFactor,
 214                         parameters.roomSize * roomScaleFactor + roomOffset);
 215     }
 216
 217     void setDamping (const float dampingToUse, const float roomSizeToUse) noexcept
 218     {
 219         for (int j = 0; j < numChannels; ++j)
 220             for (int i = numCombs; --i >= 0;)
 221                 comb[j][i].setFeedbackAndDamp (roomSizeToUse, dampingToUse);
 222     }
 223
 224     //==============================================================================
 225     class CombFilter
 226     {
 227     public:
 228         CombFilter() noexcept  : bufferSize (0), bufferIndex (0) {}
 229
 230         void setSize (const int size)
 231         {
 232             if (size != bufferSize)
 233             {
 234                 bufferIndex = 0;
 235                 buffer.malloc (size);
 236                 bufferSize = size;
 237             }
 238
 239             clear();
 240         }
 241
 242         void clear() noexcept
 243         {
 244             last = 0;
 245             buffer.clear (bufferSize);
 246         }
 247
 248         void setFeedbackAndDamp (const float f, const float d) noexcept
 249         {
 250             damp1 = d;
 251             damp2 = 1.0f - d;
 252             feedback = f;
 253         }
 254
 255         inline float process (const float input) noexcept
 256         {
 257             const float output = buffer [bufferIndex];
 258             last = (output * damp2) + (last * damp1);
 259             JUCE_UNDENORMALISE (last);
 260
 261             float temp = input + (last * feedback);
 262             JUCE_UNDENORMALISE (temp);
 263             buffer [bufferIndex] = temp;
 264             bufferIndex = (bufferIndex + 1) % bufferSize;
 265             return output;
 266         }
 267
 268     private:
 269         HeapBlock<float> buffer;
 270         int bufferSize, bufferIndex;
 271         float feedback, last, damp1, damp2;
 272
 273         JUCE_DECLARE_NON_COPYABLE (CombFilter);
 274     };
 275
 276     //==============================================================================
 277     class AllPassFilter
 278     {
 279     public:
 280         AllPassFilter() noexcept  : bufferSize (0), bufferIndex (0) {}
 281
 282         void setSize (const int size)
 283         {
 284             if (size != bufferSize)
 285             {
 286                 bufferIndex = 0;
 287                 buffer.malloc (size);
 288                 bufferSize = size;
 289             }
 290
 291             clear();
 292         }
 293
 294         void clear() noexcept
 295         {
 296             buffer.clear (bufferSize);
 297         }
 298
 299         inline float process (const float input) noexcept
 300         {
 301             const float bufferedValue = buffer [bufferIndex];
 302             float temp = input + (bufferedValue * 0.5f);
 303             JUCE_UNDENORMALISE (temp);
 304             buffer [bufferIndex] = temp;
 305             bufferIndex = (bufferIndex + 1) % bufferSize;
 306             return bufferedValue - input;
 307         }
 308
 309     private:
 310         HeapBlock<float> buffer;
 311         int bufferSize, bufferIndex;
 312
 313         JUCE_DECLARE_NON_COPYABLE (AllPassFilter);
 314     };
 315
 316     enum { numCombs = 8, numAllPasses = 4, numChannels = 2 };
 317
 318     CombFilter comb [numChannels][numCombs];
 319     AllPassFilter allPass [numChannels][numAllPasses];
 320
 321     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Reverb);
 322 };
 323
 324
 325 #endif   // __JUCE_REVERB_JUCEHEADER__