/*-----------------------------------------------------------------------------

   File:        AFdnReverb.cpp

   Description: Implementation of the time-varying FDN reverberation plug-in 

   Author:      Jasmin Frenette
   Date:        11/27/2000

-----------------------------------------------------------------------------*/

#include <windows.h>
#include <io.h>
#include <FCNTL.H>
#include <SYS\STAT.H>
#include <stdio.h>
#include <math.h>
#include <string.h>

#include "AFdnReverb.hpp"
#include "AEffEditor.hpp"

//----------------------------------------------------------------------------- 

AFdnReverbProgram::AFdnReverbProgram ()
{
   fOut = (float) 0.5;
   strcpy (name, "Init");
}

//-----------------------------------------------------------------------------

AFdnReverb::AFdnReverb (audioMasterCallback audioMaster)
   : AudioEffectX (audioMaster, 16, kNumParams)
{
   long i, j;

   programs = new AFdnReverbProgram[numPrograms];
   fOut = vu = 0;

   //
   // Parameters Initialization
   //

   fDCRevTime = 3.00f;   // Reverberation time at 0 Hz (in seconds)
   fPIRevTime = 1.25f;   // Reverberation time at Fs/2 Hz (in seconds)
   lPreDelay = 1102;      // Pre delay (in samples)

   // delay lines time constants (in samples)
#if (NB_DELAYS == 1)
   lTau[0] = 1000;
#elif (NB_DELAYS == 4)
   lTau[0] = 601;
   lTau[1] = 691;
   lTau[2] = 773;
   lTau[3] = 839;
#elif (NB_DELAYS == 8)
   lTau[0] = 601;
   lTau[1] = 691;
   lTau[2] = 773;
   lTau[3] = 839;
   lTau[4] = 919;
   lTau[5] = 997;
   lTau[6] = 1061;
   lTau[7] = 1129;
#elif (NB_DELAYS == 12)
   lTau[0] = 601;
   lTau[1] = 691;
   lTau[2] = 773;
   lTau[3] = 839;
   lTau[4] = 919;
   lTau[5] = 997;
   lTau[6] = 1061;
   lTau[7] = 1093;
   lTau[8] = 1129;
   lTau[9] = 1151;
   lTau[10] = 1171;
   lTau[11] = 1187;
#elif (NB_DELAYS == 16)
   lTau[0] = 919;
   lTau[1] = 997;
   lTau[2] = 1061;
   lTau[3] = 1093;
   lTau[4] = 1129;
   lTau[5] = 1151;
   lTau[6] = 1171;
   lTau[7] = 1187;
   lTau[8] = 1213;
   lTau[9] = 1237;
   lTau[10] = 1259;
   lTau[11] = 1283;
   lTau[12] = 1303;
   lTau[13] = 1319;
   lTau[14] = 1327;
   lTau[15] = 1361;
#endif

#if (NB_MOD_DELAYS>0)
   // delay lines modulation depth (in samples)
   for(i=0;i<NB_MOD_DELAYS;i++){
      lModDepth[i] = 6;
   }

   // Delay lines interpolators' update rates
   for(i=0;i<NB_MOD_DELAYS;i++){
      lModRate[i] = 50;   // in samples
   }

   #ifdef USE_OSC_MODULATION
      // delay lines modulation frequency (in Hertz)
      for(i=0;i<NB_MOD_DELAYS;i++){
         fModFreq[i] = (float)(2);
      }

      // delay lines modulation phase (in Degrees)
      for(i=0;i<NB_MOD_DELAYS;i++){
         fModPhase[i] = (float)(i*45);
      }

   #elif defined USE_RNG_MODULATION
      // Delay lines RNG's "a" parameters
      for(i=0;i<NB_MOD_DELAYS;i++){
         ulRngA[i] = 1664525;
      }

      // Delay lines RNG's "c" parameters
      for(i=0;i<NB_MOD_DELAYS;i++){
         ulRngC[i] = 32767;
      }

      // Delay lines RNG's seeds
      for(i=0;i<NB_MOD_DELAYS;i++){
         ulRngSeed[i] = i;
      }

      // Delay lines rngs' refresh rates
      for(i=0;i<NB_MOD_DELAYS;i++){
         lRngRate[i] = 441;   // in samples
      }
   #endif
#endif

   // Feedback matrix
   float fTwoDivByNbDelays = (float)(2.0/NB_DELAYS); // Coeff. used for speed
   for(i=0;i<NB_DELAYS;i++){
      for(j=0;j<NB_DELAYS;j++){
         if((j==(i+1))||((i==(NB_DELAYS-1))&&(j==0)))
            fA[i][j] = 1;
         else
            fA[i][j] = 0;
         fA[i][j] -= fTwoDivByNbDelays;
      }
   }
   fFeedConstant = (float)(-2.0)/NB_DELAYS;

   // Early reflexions tap times
   lTapTimeL[0] = lPreDelay + (long)(0.0090 * getSampleRate());
   lTapTimeL[1] = lPreDelay + (long)(0.0118 * getSampleRate());
   lTapTimeL[2] = lPreDelay + (long)(0.0213 * getSampleRate());
   lTapTimeL[3] = lPreDelay + (long)(0.0205 * getSampleRate());
   lTapTimeR[0] = lPreDelay + (long)(0.0145 * getSampleRate());
   lTapTimeR[1] = lPreDelay + (long)(0.0100 * getSampleRate());
   lTapTimeR[2] = lPreDelay + (long)(0.0205 * getSampleRate());
   lTapTimeR[3] = lPreDelay + (long)(0.0230 * getSampleRate());
   
   // Early reflexions tap gains
   fTapGainL[0] = (float)  1.35;
   fTapGainL[1] = (float) -1.15;
   fTapGainL[2] = (float) -1.14;
   fTapGainL[3] = (float)  1.15;
   fTapGainR[0] = (float)  1.35;
   fTapGainR[1] = (float) -1.16;
   fTapGainR[2] = (float) -1.00;
   fTapGainR[3] = (float)  1.14;

   // Set early ref FIR max delay
   earlyRefFIR.SetMaxDelay((long)(EARLY_REF_FIR_SIZE*getSampleRate()));

   float T = 1/getSampleRate();   // Sampling period
   float alpha = fPIRevTime/fDCRevTime;

   for(i=0;i<NB_DELAYS;i++){
      // IIR LPFs gain
      fkp[i] = (float)pow(10,-3*lTau[i]*T/fDCRevTime);

      // IIR LPFs feedback gain
      fbp[i] = (float)(20*log10(fkp[i])*log(10)/80*(1 - 1/pow(alpha,2)));
      dampingLPF[i].SetCoeffs(fkp[i]*(1-fbp[i]),(-1)*fbp[i]);
   }

#if (NB_MOD_DELAYS>0)
   for(i=0;i<NB_MOD_DELAYS;i++){
   #ifdef USE_OSC_MODULATION
      // Modulators
      #ifdef USE_VARIABLE_RATES
         mod[i].SetFreq(fModFreq[i]*lModRate[i], getSampleRate(),fModPhase[i]);
      #else
         mod[i].SetFreq(fModFreq[i], getSampleRate(), fModPhase[i]);
      #endif
   #elif defined USE_RNG_MODULATION
      rng[i].SetParams(ulRngA[i], ulRngC[i], ulRngSeed[i]);
      // Coeffs for a 2nd order Chebichev Butterworth LPF
      rngLpf1[i].SetCoeffs(0.0000003258000341709795, 2, -1.999758737383959,
                        0.9997587663202134);
      rngLpf2[i].SetCoeffs(0.0000003258000341709795, 2, -1.99989998432827,
                        0.999900070678988);
      mod[i].SetRefreshRate(lRngRate[i]);
      mod[i].SetModulator(&rng[i]);
      mod[i].SetLPF1(&rngLpf1[i]);
      mod[i].SetLPF2(&rngLpf2[i]);
   #endif

      // Set delay lines's parameters
      modDelayLine[i].SetNomDelay(lTau[i]);
      modDelayLine[i].SetModDepth(lModDepth[i]);
   #ifdef USE_VARIABLE_RATES
      modDelayLine[i].SetModRate(lModRate[i]);
   #endif
      modDelayLine[i].SetModulator(&mod[i]);
   }
#endif
   
   for(i=NB_MOD_DELAYS;i<NB_DELAYS;i++){
      // Set delay lines's length
      delayLine[i].SetMaxDelay(lTau[i]);
   }

   for(i=0;i<NB_DELAYS;i++){
      // Left delay lines' output gains

      /*
      fcL[i] = (float)lTau[i]/lTau[NB_DELAYS-1];
      */   
      fcL[i] = 1;  // No weighting for fcL if A is not the identity matrix

      if((i%2)!=0)
         fcL[i] *= -1;
      if((i==1)||(i==2)||(i==5)||(i==6)||(i==9)||(i==10)||(i==13)||(i==14))
         fcR[i] = -1 * fcL[i];
      else
         fcR[i] = fcL[i];
   }

#ifdef FILE_OUTPUT
   while((fh = _open("D:\\output.raw", _O_TRUNC | _O_WRONLY | _O_CREAT
      | _O_BINARY, _S_IWRITE)) == -1 ){
      MessageBox(NULL,"FDN Reverb","Unable to open output file",MB_OK);
      DebugBreak();
   }
   _close(fh);
#endif

#ifdef QUERY_PERFORMANCE
   timeSum = 0;
   counter = 0;
   pf = fopen("D:\\performance.txt","w");
   fclose(pf);
#endif

   if (programs)
      setProgram (0);

   setNumInputs (1);
   setNumOutputs (2);
   hasVu ();
   setUniqueID ('FDNR');

   suspend ();      // flush buffer
}

//-----------------------------------------------------------------------------
AFdnReverb::~AFdnReverb ()
{
   if (programs)
      delete[] programs;
}

//-----------------------------------------------------------------------------
void AFdnReverb::setProgram (long program)
{
   AFdnReverbProgram * ap = &programs[program];

   curProgram = program;
   setParameter (kOut, ap->fOut);
}

//-----------------------------------------------------------------------------
void AFdnReverb::setProgramName (char *name)
{
   strcpy (programs[curProgram].name, name);
}

//-----------------------------------------------------------------------------
void AFdnReverb::getProgramName (char *name)
{
   if (!strcmp (programs[curProgram].name, "Init"))
      sprintf (name, "%s %d", programs[curProgram].name, curProgram + 1);
   else
      strcpy (name, programs[curProgram].name);
}

//-----------------------------------------------------------------------------
void AFdnReverb::suspend ()
{
   long i;

   earlyRefFIR.Suspend();
#if (NB_MOD_DELAYS>0)
   for(i=0;i<NB_MOD_DELAYS;i++){
      modDelayLine[i].Suspend();
   }
#endif
   for(i=NB_MOD_DELAYS;i<NB_DELAYS;i++){
      delayLine[i].Suspend();
   }
   for(i=0;i<NB_DELAYS;i++){
      dampingLPF[i].Suspend();
   }
}

//-----------------------------------------------------------------------------
float AFdnReverb::getVu ()
{
   float cvu = vu;
   
   vu = 0;
   return cvu;
}

//-----------------------------------------------------------------------------
void AFdnReverb::setParameter (long index, float value)
{
   AFdnReverbProgram * ap = &programs[curProgram];

   switch (index)
   {
      case kOut :            fOut = ap->fOut = value; break;
   }
   if (editor)
      editor->postUpdate ();
}

//-----------------------------------------------------------------------------
float AFdnReverb::getParameter (long index)
{
   float v = 0;

   switch (index)
   {
      case kOut :            v = fOut; break;
   }
   return v;
}

//-----------------------------------------------------------------------------
void AFdnReverb::getParameterName (long index, char *label)
{
   switch (index)
   {
      case kOut :            strcpy (label, " Volume "); break;
   }
}

//-----------------------------------------------------------------------------
void AFdnReverb::getParameterDisplay (long index, char *text)
{
   switch (index)
   {
      case kOut :            dB2string (fOut, text); break;
   }
}

//-----------------------------------------------------------------------------
void AFdnReverb::getParameterLabel (long index, char *label)
{
   switch (index)
   {
      case kOut :            strcpy (label, "   dB   ");   break;
   }
}

//-----------------------------------------------------------------------------
void AFdnReverb::process(float **inputs, float **outputs, long sampleframes)
{
   float cvu = vu;

   long p, count;
   float xn, yn1, yn2;
   float factor;
   float fQ[NB_DELAYS], fS[NB_DELAYS];

   float *in = *inputs;
   float *out1 = outputs[0];
   float *out2 = outputs[1];

#ifdef FILE_OUTPUT
   short *piFileOut = (short*)GlobalAlloc(GPTR,2*sampleframes*sizeof(short));
#endif

#ifdef QUERY_PERFORMANCE
   QueryPerformanceFrequency(&timeFreq);
   QueryPerformanceCounter(&timeBegin);
#endif

   for(count=0;count<sampleframes;count++)
   {
        xn = *in++;   

#ifdef USE_1_DELAY
   #if (NB_MOD_DELAYS==1)
      yn1 = xn + modDelayLine[0].GetCurValue();
   #else
      yn1 = xn + delayLine[0].GetLast();
   #endif
      dampingLPF[0].Process(yn1, yn1);
      delayLine[0].Push(yn1);
      yn2 = yn1;
#else
      // xn *= fOut; // Optional global output level (VST real-time parameter)

      yn1 = yn2 = xn;

/*
      // Pre-Delay (optional)
      earlyRefFIR.Push(xn);
      xn = earlyRefFIR.GetAt(lPreDelay);

      // Get early reflections (optional)
      for(int i=0;i<NB_TAPS;i++){
         yn1 += fTapGainL[i]*earlyRefFIR.GetAt(lTapTimeL[i]);
         yn2 += fTapGainR[i]*earlyRefFIR.GetAt(lTapTimeR[i]);
      }

      // Tone correction filter should be implemented here (optional)
*/

      // Get the delay lines output, filter them and compute output
#if (NB_MOD_DELAYS>0)
      for(p=0;p<NB_MOD_DELAYS;p++){
         fQ[p] = modDelayLine[p].GetCurValue();
         dampingLPF[p].Process(fQ[p], fQ[p]);
         yn1 += fcL[p]*fQ[p];
         yn2 += fcR[p]*fQ[p];
      }
#endif
      for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
         fQ[p] = delayLine[p].GetLast();
         dampingLPF[p].Process(fQ[p], fQ[p]);
         yn1 += fcL[p]*fQ[p];
         yn2 += fcR[p]*fQ[p];
      }

      // Compute feedback
      factor = 0;
      for(p=0;p<NB_DELAYS;p++){
         factor += fQ[p];
      }
      factor *= fFeedConstant;
      for(p=1;p<NB_DELAYS;p++){
         fS[p-1] = fQ[p] + factor;
      }
      fS[NB_DELAYS-1] = fQ[0] + factor;

      // Add the input and push the samples in the delay lines
#if (NB_MOD_DELAYS>0)
      for(p=0;p<NB_MOD_DELAYS;p++){
         fS[p] += xn;
         modDelayLine[p].Push(fS[p]);
      }
#endif
      for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
         fS[p] += xn;
         delayLine[p].Push(fS[p]);
      }
#endif

#ifdef FILE_OUTPUT
      piFileOut[2*count]   = (short)(32767*yn1);
      piFileOut[2*count+1] = (short)(32767*yn2);
#endif
      (*out1++) += yn1;   // store to buss
      (*out2++) += yn2;
   }
   vu = 0; // not implemented

#ifdef FILE_OUTPUT
   fh = _open("D:\\output.raw", _O_WRONLY | _O_CREAT | _O_BINARY
            | _O_APPEND, _S_IWRITE);
   _write(fh, piFileOut, 2*sampleframes*sizeof(short));
   _close(fh);
   if(piFileOut != NULL)
      GlobalFree(piFileOut); 
#endif

#ifdef QUERY_PERFORMANCE
   QueryPerformanceCounter(&timeEnd);
   timeDelta =   (double)(timeEnd.QuadPart-timeBegin.QuadPart)
            /(double)(timeFreq.QuadPart);
   timeSum += timeDelta/sampleframes;
   counter++;
   pf = fopen("D:\\performance.txt","a");
   fprintf(pf, "%2d: %2.2f us Avrg: %2.2f us\n", counter,
         (timeDelta/sampleframes*1000000),
         (timeSum/counter*1000000));
   fclose(pf);
#endif
}