tracktion_AudioFadeCurve.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
struct AudioFadeCurve
{
    struct Linear
    {
        inline static double preadjust (double alpha) noexcept  { return alpha; }
        inline static float get (float alpha) noexcept          { return alpha; }
    };
 
    struct Convex
    {
        inline static double preadjust (double alpha) noexcept  { return alpha * (0.5 * juce::MathConstants<double>::pi); }
        inline static float get (float alpha) noexcept          { return std::sin (alpha); }
    };
 
    struct Concave
    {
        inline static double preadjust (double alpha) noexcept  { return alpha * (0.5 * juce::MathConstants<double>::pi); }
        inline static float get (float alpha) noexcept          { return 1.0f - std::cos (alpha); }
    };
 
    struct SCurve
    {
        inline static double preadjust (double alpha) noexcept  { return alpha; }
        inline static float get (float alpha) noexcept          { return (1.0f - alpha) * (1.0f - std::cos (alpha * (0.5f * juce::MathConstants<float>::pi)))
                                                                            + alpha * std::sin (alpha * (0.5f * juce::MathConstants<float>::pi)); }
    };
 
    enum Type
    {
        linear  = 1,
        convex  = 2,
        concave = 3,
        sCurve  = 4
    };
 
    template <typename CurveClass>
    static float alphaToGain (float alpha) noexcept
    {
        jassert (alpha >= 0 && alpha <= 1.0f);
        return CurveClass::get ((float) CurveClass::preadjust (alpha));
    }
 
    static float alphaToGainForType (Type type, float alpha) noexcept
    {
        if (type == convex)    return alphaToGain<Convex>  (alpha);
        if (type == concave)   return alphaToGain<Concave> (alpha);
        if (type == sCurve)    return alphaToGain<SCurve>  (alpha);
 
        jassert (type == linear);
        return alpha;
    }
 
    template <typename CurveClass, typename DestSamplePointer>
    static void renderBlock (DestSamplePointer& dest, int numSamples,
                             float startAlpha, float endAlpha) noexcept
    {
        jassert (numSamples > 0); // can only be used on non-empty blocks!
 
        const double a1 = CurveClass::preadjust (startAlpha);
        const double a2 = CurveClass::preadjust (endAlpha);
        const double delta = (a2 - a1) / numSamples;
        double alpha = a1;
 
        while (--numSamples >= 0)
        {
            dest.apply (CurveClass::get ((float) alpha));
            alpha += delta;
        }
    }
 
    template <typename DestSamplePointer>
    static void renderBlockForType (DestSamplePointer& dest, int numSamples,
                                    float startAlpha, float endAlpha, Type type) noexcept
    {
        jassert (numSamples > 0);
 
        switch (type)
        {
            case linear:    renderBlock<Linear>  (dest, numSamples, startAlpha, endAlpha); break;
            case convex:    renderBlock<Convex>  (dest, numSamples, startAlpha, endAlpha); break;
            case concave:   renderBlock<Concave> (dest, numSamples, startAlpha, endAlpha); break;
            case sCurve:    renderBlock<SCurve>  (dest, numSamples, startAlpha, endAlpha); break;
            default:        jassertfalse; break;
        }
    }
 
    struct CrossfadeLevels
    {
        CrossfadeLevels (float alpha) noexcept
            : gain1 (alphaToGain<AudioFadeCurve::Convex> (alpha)),
              gain2 (alphaToGain<AudioFadeCurve::Convex> (1.0f - alpha))
        {
        }
 
        float gain1, gain2;
    };
 
    static void applyCrossfadeSection (juce::AudioBuffer<float>&, int channel,
                                       int startSample, int numSamples,
                                       Type type,
                                       float startAlpha,
                                       float endAlpha);
 
    static void applyCrossfadeSection (juce::AudioBuffer<float>&,
                                       int startSample, int numSamples,
                                       Type type,
                                       float startAlpha,
                                       float endAlpha);
 
    static void addWithCrossfade (juce::AudioBuffer<float>& dest,
                                  const juce::AudioBuffer<float>& src,
                                  int destChannel, int destStartIndex,
                                  int sourceChannel, int sourceStartIndex,
                                  int numSamples,
                                  Type type,
                                  float startAlpha,
                                  float endAlpha);
 
    static void drawFadeCurve (juce::Graphics&, const AudioFadeCurve::Type,
                               float x1, float x2, float top, float bottom, juce::Rectangle<int> clip);
};
 
}} // namespace tracktion { inline namespace engine
 
 
namespace juce
{
    template <>
    struct VariantConverter<tracktion::engine::AudioFadeCurve::Type>
    {
        static tracktion::engine::AudioFadeCurve::Type fromVar (const var& v)   { return (tracktion::engine::AudioFadeCurve::Type) static_cast<int> (v); }
        static var toVar (tracktion::engine::AudioFadeCurve::Type v)            { return static_cast<int> (v); }
    };
}