Gain.h

// DSPark - Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi - MIT License
 
#pragma once
 
#include "../Core/DspMath.h"
#include "../Core/SmoothedValue.h"
#include "../Core/AudioSpec.h"
#include "../Core/AudioBuffer.h"
#include "../Core/SimdOps.h"
#include "../Core/StateBlob.h"
 
#include <algorithm>
#include <atomic>
#include <cmath>
#include <cstdint>
#include <vector>
 
namespace dspark {
 
template <FloatType T>
class Gain
{
public:
    Gain()
    {
        gainSmooth_.reset(T(1));
    }
 
    ~Gain() = default;
 
    void prepare(double sampleRate, double rampTimeMs = 10.0)
    {
        if (!(sampleRate > 0.0) || !std::isfinite(sampleRate) || !std::isfinite(rampTimeMs)) return;
        sampleRate_ = sampleRate;
        rampTimeMs_.store(std::max(0.0, rampTimeMs), std::memory_order_relaxed);
 
        gainSmooth_.prepare(sampleRate, rampTimeMs_.load(std::memory_order_relaxed));
        forceSynchronize();
    }
 
    void prepare(const AudioSpec& spec)
    {
        prepare(spec.sampleRate, rampTimeMs_.load(std::memory_order_relaxed));
    }
 
    void setGainDb(T dB) noexcept
    {
        if (!std::isfinite(dB)) return;
        targetGainLinear_.store(decibelsToGain(dB), std::memory_order_relaxed);
    }
 
    void setGainLinear(T linear) noexcept
    {
        if (!std::isfinite(linear)) return;
        targetGainLinear_.store(std::max(T(0), linear), std::memory_order_relaxed);
    }
 
    [[nodiscard]] T getGainDb() const noexcept
    {
        return gainToDecibels(targetGainLinear_.load(std::memory_order_relaxed));
    }
 
    [[nodiscard]] T getGainLinear() const noexcept
    {
        return targetGainLinear_.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] T getCurrentGain() const noexcept
    {
        return publishedGain_.load(std::memory_order_relaxed);
    }
 
    void setMuted(bool muted) noexcept
    {
        muted_.store(muted, std::memory_order_relaxed);
    }
 
    [[nodiscard]] bool isMuted() const noexcept { return muted_.load(std::memory_order_relaxed); }
 
    void setInverted(bool inverted) noexcept 
    { 
        inverted_.store(inverted, std::memory_order_relaxed); 
    }
 
    [[nodiscard]] bool isInverted() const noexcept { return inverted_.load(std::memory_order_relaxed); }
 
    void setRampTime(double rampTimeMs) noexcept
    {
        if (!std::isfinite(rampTimeMs)) return;
        rampTimeMs_.store(std::max(0.0, rampTimeMs), std::memory_order_relaxed);
        rampTimeChanged_.store(true, std::memory_order_release);
    }
 
    void processBlock(AudioBufferView<T> buffer) noexcept
    {
        updateInternalState();
 
        const int nCh = buffer.getNumChannels();
        const int nS = buffer.getNumSamples();
 
        if (nCh == 1)
        {
            process(buffer.getChannel(0), nS);
        }
        else
        {
            T* channels[16];
            int useCh = nCh < 16 ? nCh : 16;
            for (int c = 0; c < useCh; ++c)
                channels[c] = buffer.getChannel(c);
            process(channels, useCh, nS);
        }
    }
 
    void process(T* data, int numSamples) noexcept
    {
        updateInternalState();
        int i = 0;
 
        // Per-sample ramp (branchless in the hot path)
        for (; i < numSamples && gainSmooth_.isSmoothing(); ++i)
        {
            data[i] *= gainSmooth_.getNextValue();
        }
 
        // SIMD bulk path
        if (i < numSamples)
        {
            simd::applyGain(data + i, gainSmooth_.getCurrentValue(), numSamples - i);
        }
 
        publishGain();
    }
 
    void process(T** channelData, int numChannels, int numSamples) noexcept
    {
        updateInternalState();
        int i = 0;
 
        for (; i < numSamples && gainSmooth_.isSmoothing(); ++i)
        {
            const T g = gainSmooth_.getNextValue();
            for (int ch = 0; ch < numChannels; ++ch)
                channelData[ch][i] *= g;
        }
 
        if (i < numSamples)
        {
            const T g = gainSmooth_.getCurrentValue();
            const int remaining = numSamples - i;
            for (int ch = 0; ch < numChannels; ++ch)
                simd::applyGain(channelData[ch] + i, g, remaining);
        }
 
        publishGain();
    }
 
    void process(const T* input, T* output, int numSamples) noexcept
    {
        updateInternalState();
        int i = 0;
 
        for (; i < numSamples && gainSmooth_.isSmoothing(); ++i)
        {
            output[i] = input[i] * gainSmooth_.getNextValue();
        }
 
        if (i < numSamples)
        {
            const T g = gainSmooth_.getCurrentValue();
            const int remaining = numSamples - i;
            
            // Allow out-of-place SIMD by copying then applying in-place SIMD gain
            std::copy_n(input + i, remaining, output + i);
            simd::applyGain(output + i, g, remaining);
        }
 
        publishGain();
    }
 
    void skipRamp() noexcept
    {
        forceSynchronize();
    }
 
    void reset() noexcept
    {
        forceSynchronize();
    }
 
 
    [[nodiscard]] std::vector<uint8_t> getState() const
    {
        StateWriter w(stateId("GAIN"), 1);
        w.write("gainLinear", static_cast<float>(targetGainLinear_.load(std::memory_order_relaxed)));
        w.write("rampMs", static_cast<float>(rampTimeMs_.load(std::memory_order_relaxed)));
        w.write("muted", muted_.load(std::memory_order_relaxed));
        w.write("inverted", inverted_.load(std::memory_order_relaxed));
        return w.blob();
    }
 
    bool setState(const uint8_t* data, size_t size)
    {
        StateReader r(data, size);
        if (!r.isValid() || r.processorId() != stateId("GAIN")) return false;
        setGainLinear(static_cast<T>(r.read("gainLinear", 1.0f)));
        setRampTime(static_cast<double>(r.read("rampMs", 10.0f)));
        setMuted(r.read("muted", false));
        setInverted(r.read("inverted", false));
        return true;
    }
 
protected:
    inline void publishGain() noexcept
    {
        publishedGain_.store(gainSmooth_.getCurrentValue(), std::memory_order_relaxed);
    }
 
    inline void updateInternalState() noexcept
    {
        // exchange (not load+store: a publication landing between the two
        // would be lost) with acquire, pairing with setRampTime's release.
        if (rampTimeChanged_.exchange(false, std::memory_order_acquire))
            gainSmooth_.setRampTime(sampleRate_, rampTimeMs_.load(std::memory_order_relaxed));
 
        const T baseTarget = muted_.load(std::memory_order_relaxed) ? T(0) 
                             : targetGainLinear_.load(std::memory_order_relaxed);
        
        const T finalTarget = inverted_.load(std::memory_order_relaxed) ? -baseTarget : baseTarget;
 
        if (finalTarget != currentTarget_)
        {
            gainSmooth_.setTargetValue(finalTarget);
            currentTarget_ = finalTarget;
        }
    }
 
    void forceSynchronize() noexcept
    {
        rampTimeChanged_.store(false, std::memory_order_relaxed);
        
        const T baseTarget = muted_.load(std::memory_order_relaxed) ? T(0) 
                             : targetGainLinear_.load(std::memory_order_relaxed);
        const T finalTarget = inverted_.load(std::memory_order_relaxed) ? -baseTarget : baseTarget;
        
        currentTarget_ = finalTarget;
        gainSmooth_.reset(currentTarget_);
        publishedGain_.store(gainSmooth_.getCurrentValue(), std::memory_order_relaxed);
    }
 
    double sampleRate_ = 48000.0;
    
    // Audio Thread State
    T currentTarget_ { T(1) };
    SmoothedValue<T> gainSmooth_;
 
    // Atomic Communication (UI -> Audio Thread)
    std::atomic<T> publishedGain_ { T(1) }; 
    std::atomic<T> targetGainLinear_ { T(1) };
    std::atomic<double> rampTimeMs_ { 10.0 };
    std::atomic<bool> rampTimeChanged_ { false };
    std::atomic<bool> muted_ { false };
    std::atomic<bool> inverted_ { false };
};
 
} // namespace dspark