//
//  AudioLimiter.cpp
//  libraries/audio/src
//
//  Created by Ken Cooke on 2/11/15.
//  Copyright 2016 High Fidelity, Inc.
//

#include "AudioLimiter.h"

#include <assert.h>

#include "AudioDynamics.h"

//
// Limiter (common)
//
class LimiterImpl {
protected:

    static const int NARC = 64;
    int32_t _holdTable[NARC];
    int32_t _releaseTable[NARC];

    int32_t _rmsAttack = 0x7fffffff;
    int32_t _rmsRelease = 0x7fffffff;
    int32_t _arcRelease = 0x7fffffff;

    int32_t _threshold = 0;
    int32_t _attn = 0;
    int32_t _rms = 0;
    int32_t _arc = 0;

    int _sampleRate;
    float _outGain = 0.0f;

public:
    LimiterImpl(int sampleRate);
    virtual ~LimiterImpl() {}

    void setThreshold(float threshold);
    void setRelease(float release);

    int32_t envelope(int32_t attn);

    virtual void process(float* input, int16_t* output, int numFrames) = 0;
};

LimiterImpl::LimiterImpl(int sampleRate) {

    sampleRate = MAX(sampleRate, 8000);
    sampleRate = MIN(sampleRate, 96000);
    _sampleRate = sampleRate;

    // defaults
    setThreshold(0.0f);
    setRelease(250.0f);
}

//
// Set the limiter threshold (dB)
// Brickwall limiting will begin when the signal exceeds the threshold.
// Makeup gain is applied, to reach but never exceed the output ceiling.
//
void LimiterImpl::setThreshold(float threshold) {

    const double OUT_CEILING = -0.3;    // cannot be 0.0, due to dither
    const double Q31_TO_Q15 = 32768 / 2147483648.0;

    // limiter threshold = -48dB to 0dB
    threshold = MAX(threshold, -48.0f);
    threshold = MIN(threshold, 0.0f);

    // limiter threshold in log2 domain
    _threshold = (int32_t)(-(double)threshold * DB_TO_LOG2 * (1 << LOG2_FRACBITS));
    _threshold += LOG2_BIAS + EXP2_BIAS;
    _threshold += LOG2_HEADROOM << LOG2_FRACBITS;

    // makeup gain and conversion to 16-bit
    _outGain = (float)(dBToGain(OUT_CEILING - (double)threshold) * Q31_TO_Q15);
}

//
// Set the limiter release time (milliseconds)
// This is a base value that scales the adaptive hold and release algorithms.
//
void LimiterImpl::setRelease(float release) {

    const double MAXHOLD = 0.100;   // max hold = 100ms
    const double MINREL = 0.025;    // min release = 0.025 * release
    const int NHOLD = 16;           // adaptive hold to adaptive release transition

    // limiter release = 50 to 5000ms
    release = MAX(release, 50.0f);
    release = MIN(release, 5000.0f);

    int32_t maxRelease = msToTc((double)release, _sampleRate);

    _rmsAttack = msToTc(0.1 * (double)release, _sampleRate);
    _rmsRelease = maxRelease;

    // Compute ARC tables, working from low peak/rms to high peak/rms.
    //
    // At low peak/rms, release = max and hold is progressive to max
    // At high peak/rms, hold = 0 and release is progressive to min

    double x = MAXHOLD * _sampleRate;
    double xstep = x / NHOLD;   // 1.0 to 1.0/NHOLD

    int i = 0;
    for (; i < NHOLD; i++) {

        // max release
        _releaseTable[i] = maxRelease;

        // progressive hold
        _holdTable[i] = (int32_t)((maxRelease - 0x7fffffff) / x);
        _holdTable[i] = MIN(_holdTable[i], -1); // prevent 0 on long releases

        x -= xstep;
        x = MAX(x, 1.0);
    }

    x = release;
    xstep = x * (1.0-MINREL) / (NARC-NHOLD-1);  // 1.0 to MINREL

    for (; i < NARC; i++) {

        // progressive release
        _releaseTable[i] = msToTc(x, _sampleRate);

        // min hold
        _holdTable[i] = (_releaseTable[i] - 0x7fffffff);    // 1 sample

        x -= xstep;
    }
}

//
// Limiter envelope processing
// zero attack, adaptive hold and release
//
int32_t LimiterImpl::envelope(int32_t attn) {

    // table of (1/attn) for 1dB to 6dB, rounded to prevent overflow
    static const int16_t invTable[64] = {
        0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 
        0x6000, 0x6000, 0x5d17, 0x5555, 0x4ec4, 0x4924, 0x4444, 0x4000, 
        0x3c3c, 0x38e3, 0x35e5, 0x3333, 0x30c3, 0x2e8b, 0x2c85, 0x2aaa, 
        0x28f5, 0x2762, 0x25ed, 0x2492, 0x234f, 0x2222, 0x2108, 0x2000, 
        0x1f07, 0x1e1e, 0x1d41, 0x1c71, 0x1bac, 0x1af2, 0x1a41, 0x1999, 
        0x18f9, 0x1861, 0x17d0, 0x1745, 0x16c1, 0x1642, 0x15c9, 0x1555, 
        0x14e5, 0x147a, 0x1414, 0x13b1, 0x1352, 0x12f6, 0x129e, 0x1249, 
        0x11f7, 0x11a7, 0x115b, 0x1111, 0x10c9, 0x1084, 0x1041, 0x1000, 
    };

    if (attn < _attn) {

        // RELEASE
        // update release before use, to implement hold = 0

        _arcRelease += _holdTable[_arc];                        // update progressive hold
        _arcRelease = MAX(_arcRelease, _releaseTable[_arc]);    // saturate at final value

        attn += MULQ31((_attn - attn), _arcRelease);            // apply release

    } else {

        // ATTACK
        // update ARC with normalized peak/rms
        //
        // arc = (attn-rms)*6/1    for attn < 1dB
        // arc = (attn-rms)*6/attn for attn = 1dB to 6dB
        // arc = (attn-rms)*6/6    for attn > 6dB

        size_t bits = MIN(attn >> 20, 0x3f);    // saturate 1/attn at 6dB
        _arc = MAX(attn - _rms, 0);             // peak/rms = (attn-rms)
        _arc = MULHI(_arc, invTable[bits]);     // normalized peak/rms = (attn-rms)/attn
        _arc = MIN(_arc, NARC - 1);             // saturate at 6dB

        _arcRelease = 0x7fffffff;               // reset release
    }
    _attn = attn;

    // Update the RMS estimate after release is applied.
    // The feedback loop with adaptive hold will damp any sustained modulation distortion.

    int32_t tc = (attn > _rms) ? _rmsAttack : _rmsRelease;
    _rms = attn + MULQ31((_rms - attn), tc);

    return attn;
}

//
// Limiter (mono)
//
template<int N>
class LimiterMono : public LimiterImpl {

    MinFilter<N> _filter;
    MonoDelay<N> _delay;

public:
    LimiterMono(int sampleRate) : LimiterImpl(sampleRate) {}

    void process(float* input, int16_t* output, int numFrames) override;
};

template<int N>
void LimiterMono<N>::process(float* input, int16_t* output, int numFrames) {

    for (int n = 0; n < numFrames; n++) {

        // peak detect and convert to log2 domain
        int32_t peak = peaklog2(&input[n]);

        // compute limiter attenuation
        int32_t attn = MAX(_threshold - peak, 0);

        // apply envelope
        attn = envelope(attn);

        // convert from log2 domain
        attn = fixexp2(attn);

        // lowpass filter
        attn = _filter.process(attn);
        float gain = attn * _outGain;

        // delay audio
        float x = input[n];
        _delay.process(x);

        // apply gain
        x *= gain;

        // apply dither
        x += dither();

        // store 16-bit output
        output[n] = (int16_t)floatToInt(x);
    }
}

//
// Limiter (stereo)
//
template<int N>
class LimiterStereo : public LimiterImpl {

    MinFilter<N> _filter;
    StereoDelay<N> _delay;

public:
    LimiterStereo(int sampleRate) : LimiterImpl(sampleRate) {}

    // interleaved stereo input/output
    void process(float* input, int16_t* output, int numFrames) override;
};

template<int N>
void LimiterStereo<N>::process(float* input, int16_t* output, int numFrames) {

    for (int n = 0; n < numFrames; n++) {

        // peak detect and convert to log2 domain
        int32_t peak = peaklog2(&input[2*n+0], &input[2*n+1]);

        // compute limiter attenuation
        int32_t attn = MAX(_threshold - peak, 0);

        // apply envelope
        attn = envelope(attn);

        // convert from log2 domain
        attn = fixexp2(attn);

        // lowpass filter
        attn = _filter.process(attn);
        float gain = attn * _outGain;

        // delay audio
        float x0 = input[2*n+0];
        float x1 = input[2*n+1];
        _delay.process(x0, x1);

        // apply gain
        x0 *= gain;
        x1 *= gain;

        // apply dither
        float d = dither();
        x0 += d;
        x1 += d;

        // store 16-bit output
        output[2*n+0] = (int16_t)floatToInt(x0);
        output[2*n+1] = (int16_t)floatToInt(x1);
    }
}

//
// Limiter (quad)
//
template<int N>
class LimiterQuad : public LimiterImpl {

    MinFilter<N> _filter;
    QuadDelay<N> _delay;

public:
    LimiterQuad(int sampleRate) : LimiterImpl(sampleRate) {}

    // interleaved quad input/output
    void process(float* input, int16_t* output, int numFrames) override;
};

template<int N>
void LimiterQuad<N>::process(float* input, int16_t* output, int numFrames) {

    for (int n = 0; n < numFrames; n++) {

        // peak detect and convert to log2 domain
        int32_t peak = peaklog2(&input[4*n+0], &input[4*n+1], &input[4*n+2], &input[4*n+3]);

        // compute limiter attenuation
        int32_t attn = MAX(_threshold - peak, 0);

        // apply envelope
        attn = envelope(attn);

        // convert from log2 domain
        attn = fixexp2(attn);

        // lowpass filter
        attn = _filter.process(attn);
        float gain = attn * _outGain;

        // delay audio
        float x0 = input[4*n+0];
        float x1 = input[4*n+1];
        float x2 = input[4*n+2];
        float x3 = input[4*n+3];
        _delay.process(x0, x1, x2, x3);

        // apply gain
        x0 *= gain;
        x1 *= gain;
        x2 *= gain;
        x3 *= gain;

        // apply dither
        float d = dither();
        x0 += d;
        x1 += d;
        x2 += d;
        x3 += d;

        // store 16-bit output
        output[4*n+0] = (int16_t)floatToInt(x0);
        output[4*n+1] = (int16_t)floatToInt(x1);
        output[4*n+2] = (int16_t)floatToInt(x2);
        output[4*n+3] = (int16_t)floatToInt(x3);
    }
}

//
// Public API
//

AudioLimiter::AudioLimiter(int sampleRate, int numChannels) {

    if (numChannels == 1) {

        // ~1.5ms lookahead for all rates
        if (sampleRate < 16000) {
            _impl = new LimiterMono<16>(sampleRate);
        } else if (sampleRate < 32000) {
            _impl = new LimiterMono<32>(sampleRate);
        } else if (sampleRate < 64000) {
            _impl = new LimiterMono<64>(sampleRate);
        } else {
            _impl = new LimiterMono<128>(sampleRate);
        }

    } else if (numChannels == 2) {

        // ~1.5ms lookahead for all rates
        if (sampleRate < 16000) {
            _impl = new LimiterStereo<16>(sampleRate);
        } else if (sampleRate < 32000) {
            _impl = new LimiterStereo<32>(sampleRate);
        } else if (sampleRate < 64000) {
            _impl = new LimiterStereo<64>(sampleRate);
        } else {
            _impl = new LimiterStereo<128>(sampleRate);
        }

    } else if (numChannels == 4) {

        // ~1.5ms lookahead for all rates
        if (sampleRate < 16000) {
            _impl = new LimiterQuad<16>(sampleRate);
        } else if (sampleRate < 32000) {
            _impl = new LimiterQuad<32>(sampleRate);
        } else if (sampleRate < 64000) {
            _impl = new LimiterQuad<64>(sampleRate);
        } else {
            _impl = new LimiterQuad<128>(sampleRate);
        }

    } else {
        assert(0); // unsupported
    }
}

AudioLimiter::~AudioLimiter() {
    delete _impl;
}

void AudioLimiter::render(float* input, int16_t* output, int numFrames) {
    _impl->process(input, output, numFrames);
}

void AudioLimiter::setThreshold(float threshold) {
    _impl->setThreshold(threshold);
}

void AudioLimiter::setRelease(float release) {
    _impl->setRelease(release);
}