hart_segmentedenvelope.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <cmath>  // pow(), abs()
 
#include "envelopes/hart_envelope.hpp"
#include "hart_exceptions.hpp"
#include "hart_utils.hpp"
 
namespace hart
{
 
/// @brief A simple envelope constructed from semgents
/// @ingroup Envelopes
class SegmentedEnvelope:
    public Envelope
{
public:
    // TODO: Log curve?
    /// @brief Determines a shape of ramp curve
    enum class Shape
    {
        linear,  ///< Linear curve
        exponential,  ///< Exponential curve
        sCurve  ///< S-curve
    };
 
    /// @brief Creates a segmented envelope instance
    /// @param startValue Initial value of the envelope, in any unit
    SegmentedEnvelope (double startValue):
        m_resetValue (startValue),
        m_beginValue (startValue),
        m_endValue (startValue),
        m_currentValue (startValue)
    {
    }
 
    void renderNextBlock (size_t blockSize, std::vector<double>& valuesOutput) override
    {
        // TODO: Make this statement strict (valuesOutput.size() != blockSize) once we have a proper EnvelopeBuffers class
        if (valuesOutput.size() < blockSize)
        {
            HART_WARNING ("Make sure to configure your envelope container size before processing audio");
            valuesOutput.resize (blockSize);
        }
 
        for (size_t i = 0; i < blockSize; ++i)
        {
            advance (m_frameTimeSeconds);
            valuesOutput[i] = m_currentValue;
        }
    }
 
    void prepare (double sampleRateHz, size_t /* maxBlockSizeFrames */) override
    {
        if (sampleRateHz < 0 || floatsEqual (sampleRateHz, 0.0))
            HART_THROW_OR_RETURN_VOID (hart::ValueError, "Illegal sample rate value");
 
        m_frameTimeSeconds = 1.0 / sampleRateHz;
    }
 
    void reset() override
    {
        m_currentTimeSeconds = 0.0;
        m_currentSegmentIndex = 0;
        m_currentValue = m_resetValue;
    }
 
    /// @brief Adds a flat horizontal section to the envelope
    /// @param durationSeconds Duration of the new segment in seconds
    SegmentedEnvelope& hold (double durationSeconds)
    {
        //m_segments.emplace_back (durationSeconds, m_endValue, Shape::linear, true);
        m_segments.push_back (Segment { durationSeconds, m_endValue, Shape::linear, true });
        return *this;
    }
 
    /// @brief Adds a transitional section to the envelope
    /// @param targetValue Value at the end of transition, in any unit
    /// @param durationSeconds Duration of the the transition in seconds
    /// @param shape Shape of the transition ramp curve
    SegmentedEnvelope& rampTo (double targetValue, double durationSeconds, Shape shape = Shape::linear)
    {
        m_segments.push_back (Segment { durationSeconds, targetValue, shape, false });
        //m_segments.emplace_back (durationSeconds, targetValue, shape, false);
        m_endValue = targetValue;
        return *this;
    }
 
    /// @brief Created a copy of the envelope wrapped in a smart pointer
    std::unique_ptr<Envelope> copy() const override
    {
        return hart::make_unique<SegmentedEnvelope> (*this);
    }
 
private:
    struct Segment
    {
        double durationSeconds;
        double targetValue;
        Shape shape;
        bool isHold;
 
        Segment (double d, double t, Shape s = Shape::linear, bool h = false):
            durationSeconds (d), targetValue (t), shape (s), isHold (h) {}
    };
 
    const double m_resetValue;
    double m_beginValue;
    double m_endValue;
    std::vector<Segment> m_segments;
 
    double m_currentTimeSeconds = 0.0;
    size_t m_currentSegmentIndex = 0;
    double m_currentValue;
 
    double m_frameTimeSeconds = 1.0 / 44100.0;
 
    void advance (double timeSeconds)
    {
        m_currentTimeSeconds += timeSeconds;
 
        // TODO: Less nesting here
        while (m_currentSegmentIndex < m_segments.size())
        {
            const Segment& currentSegment = m_segments[m_currentSegmentIndex];
 
            if (m_currentTimeSeconds < currentSegment.durationSeconds)
            {
                const double t = m_currentTimeSeconds / currentSegment.durationSeconds;
 
                if (currentSegment.isHold)
                {
                    m_currentValue = currentSegment.targetValue;
                }
                else
                {
                    switch (currentSegment.shape)
                    {
                        case Shape::linear:
                        {
                            m_currentValue = m_beginValue + (currentSegment.targetValue - m_beginValue) * t;
                            break;
                        }
 
                        case Shape::exponential:
                        {
                            const double ratio = currentSegment.targetValue / m_beginValue;
 
                            if (std::abs (ratio - 1.0) < 1e-9)
                            {
                                m_currentValue = m_beginValue;
                                break;
                            }
 
                            const bool isFallingCurve = ratio > 1.0;
 
                            if (isFallingCurve)
                            {
                                double k = std::log (ratio) / currentSegment.durationSeconds;
                                m_currentValue = m_beginValue * std::exp (k * m_currentTimeSeconds);
                            }
                            else
                            {
                                double k = std::log (1.0 / ratio) / currentSegment.durationSeconds;
                                m_currentValue = m_beginValue * std::exp (-k * m_currentTimeSeconds);
                            }
 
                            break;
                        }
 
                        case Shape::sCurve:
                        {
                            const double smoothstep = t * t * (3.0 - 2.0 * t);
                            m_currentValue = m_beginValue + (currentSegment.targetValue - m_beginValue) * smoothstep;
                            break;
                        }
                    }
                }
 
                break;
            }
            else
            {
                m_currentTimeSeconds -= currentSegment.durationSeconds;
                m_beginValue = currentSegment.targetValue;
                ++m_currentSegmentIndex;
            }
        }
 
        if (m_currentSegmentIndex >= m_segments.size())
            m_currentValue = m_segments.back().targetValue;
    }
};
 
HART_ENVELOPE_DECLARE_ALIASES_FOR (SegmentedEnvelope)
 
}  // namespace hart