#include "compressorprocessor.h"
#include <math.h>

CompressorProcessor::CompressorProcessor(uint8_t channels, uint32_t samplerate)
: Processor(channels, samplerate),
  _threshold(70.0f),
  _slope(80.0f),
  _tla(2),
  _tw(100),
  _ta(10),
  _tr(300),
  _g(1.0f)
{
}
CompressorProcessor::~CompressorProcessor()
{
}
void CompressorProcessor::process(sample_t* in, sample_t* out, uint32_t samples)
{
    sample_t* buf[2];
    buf[0] = new sample_t[samples];
    buf[1] = new sample_t[samples];
    uint32_t j, k;
    j = 0;
    for (uint32_t i = 0; i < samples; i += 2) {
        buf[0][j] = in[i];
        ++j;
    }
    if (_numChannels == 1)
        processMono(in, out, samples);
    else if (_numChannels == 2)
        processStereo(buf[0], buf[1], j);
    k = j;
    j = 0;
    for (uint32_t i = 0; i < k; ++i) {
        out[j] = buf[1][i];
        j += 2;
    }
    delete[] buf[0];
    delete[] buf[1];
}
void CompressorProcessor::processMono(sample_t* in, sample_t* out, uint32_t samples)
{
    /*
    void compress
       (
           float*  wav_in,     // signal
           int     n,          // N samples
           double  threshold,  // threshold (percents)
           double  slope,      // slope angle (percents)
           int     _sampleRate,         // sample rate (smp/sec)
           double  _tla,        // lookahead  (ms)
           double  _tw,       // window time (ms)
           double  _ta,       // attack time  (ms)
           double  _tr        // release time (ms)
       )*/

    double threshold = _threshold * 0.01; // threshold to unity (0...1)
    double slope = _slope * 0.01; // slope to unity
    _tla *= 1e-3; // lookahead time to seconds
    _tw *= 1e-3; // window time to seconds
    _ta *= 1e-3; // attack time to seconds
    _tr *= 1e-3; // release time to seconds

    // attack and release "per sample decay"
    double att = (_ta == 0.0) ? (0.0) : exp(-1.0 / (_sampleRate * _ta));
    double rel = (_tr == 0.0) ? (0.0) : exp(-1.0 / (_sampleRate * _tr));

    // envelope
    double env = 0.0;

    // sample offset to lookahead wnd start
    int lhsmp = ( int )(_sampleRate * _tla);

    // samples count in lookahead window
    int nrms = ( int )(_sampleRate * _tw);

    // for each sample...
    for (int i = 0; i < samples; ++i) {
        // now compute RMS
        double summ = 0;

        // for each sample in window
        for (int j = 0; j < nrms; ++j) {
            int lki = i + j + lhsmp;
            double smp;

            // if we in bounds of signal?
            // if so, convert to mono
            if (lki < samples)
                smp = in[lki];
            else
                smp = 0.0; // if we out of bounds we just get zero in smp

            summ += smp * smp; // square em..
        }

        double rms = sqrt(summ / nrms); // root-mean-square

        // dynamic selection: attack or release?
        double theta = rms > env ? att : rel;

        // smoothing with capacitor, envelope extraction...
        // here be aware of pIV denormal numbers glitch
        env = (1.0 - theta) * rms + theta * env;

        // the very easy hard knee 1:N compressor
        double gain = 1.0;
        if (env > threshold)
            gain = gain - (env - threshold) * slope;

        // result - hard kneed compressed channels...
        out[i] = in[i] * gain * _g;
    }
}
void CompressorProcessor::processStereo(sample_t* in, sample_t* out, uint32_t samples)
{
    /*
      void compress
         (
             float*  wav_in,     // signal
             int     n,          // N samples
             double  threshold,  // threshold (percents)
             double  slope,      // slope angle (percents)
             int     _sampleRate,         // sample rate (smp/sec)
             double  _tla,        // lookahead  (ms)
             double  _tw,       // window time (ms)
             double  _ta,       // attack time  (ms)
             double  _tr        // release time (ms)
         )*/

    double threshold = _threshold * 0.01; // threshold to unity (0...1)
    double slope = _slope * 0.01; // slope to unity
    double tla = _tla * 1e-3; // lookahead time to seconds
    double tw = _tw * 1e-3; // window time to seconds
    double ta = _ta * 1e-3; // attack time to seconds
    double tr = _tr * 1e-3; // release time to seconds

    // attack and release "per sample decay"
    double att = (ta == 0.0) ? (0.0) : exp(-1.0 / (_sampleRate * ta));
    double rel = (tr == 0.0) ? (0.0) : exp(-1.0 / (_sampleRate * tr));

    // envelope
    double env = 0.0;

    // sample offset to lookahead wnd start
    int lhsmp = ( int )(_sampleRate * tla);

    // samples count in lookahead window
    int nrms = ( int )(_sampleRate * tw);

    // for each sample...
    for (int i = 0; i < samples; ++i) {
        // now compute RMS
        double summ = 0;

        // for each sample in window
        for (int j = 0; j < nrms; ++j) {
            int lki = i + j + lhsmp;
            double smp;

            // if we in bounds of signal?
            // if so, convert to mono
            if (lki < samples)
                smp = in[lki];
            else
                smp = 0.0; // if we out of bounds we just get zero in smp

            summ += smp * smp; // square em..
        }

        double rms = sqrt(summ / nrms); // root-mean-square

        // dynamic selection: attack or release?
        double theta = rms > env ? att : rel;

        // smoothing with capacitor, envelope extraction...
        // here be aware of pIV denormal numbers glitch
        env = (1.0 - theta) * rms + theta * env;

        // the very easy hard knee 1:N compressor
        double gain = 1.0;
        if (env > threshold)
            gain = gain - (env - threshold) * slope;

        // result - hard kneed compressed channels...
        out[i] = in[i] * gain * _g;
    }
}