//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Sun Apr 20 19:03:37 GMT-0800 1997
// Last Modified: Fri Mar 27 23:35:58 GMT-0800 1998
// Last Modified: Sun Jul  8 17:05:56 PDT 2001 (bug fixes by MD and CSS)
// Filename:      ...sig/maint/code/Filter/Comb/Comb.cpp
// Web Address:   http://sig.sapp.org/src/sigSignal/Comb.cpp
// Documentation: http://sig.sapp.org/doc/classes/Comb
// Syntax:        C++ 
//

#include "Comb.h"
#include <stdlib.h>
#include <math.h>


//////////////////////////////
//
// Comb::Comb -- sets the minimum resonating frequency to 12 Hz.
//

Comb::Comb(void) {
   setName("Comb");
   brandname = FILTER;
   buffsize = 0;
   maxbuffsize = 0;
   setMinFund(12);         // default minimum fundamental of comb is 12 Hz.
   setGain(0.5);           // related to reverb time of sound
   setFund(440);           // fundamental frequency of comb filter
   clear();
}



//////////////////////////////
//
// Comb::~Comb --
//

Comb::~Comb() { 
   // do nothing
}



//////////////////////////////
//
// Comb::action --
//

void Comb::action(void) {
   outputValue = circularQueue.extract();
   circularQueue.insert(getSignal() + getGain() * outputValue);
}



//////////////////////////////
//
// Comb::clear -- initialize internal signal variables to zeros.
//

void Comb::clear(void) {
   outputValue = 0.0;
   circularQueue.reset();
   for (int i=0; i<buffsize; i++) {
      circularQueue.insert(0.0);
   }
}



//////////////////////////////
//
// Comb::getDelaySamples -- returns size of the comb filter delay in samples.
//

int Comb::getDelaySamples(void) {
   return buffsize;
}



//////////////////////////////
//
// Comb::getFund -- return the pitch of the comb filter resonator
//    in Hz.
//

sampleType Comb::getFund(void) {
   return getSrate()/buffsize;
}



//////////////////////////////
//
// Comb::getLoopTime -- gets the delay time in seconds.
//

sampleType Comb::getLoopTime(void) {
   return buffsize/getSrate();
}
   


//////////////////////////////
//
// Comb::getMinFund -- returns the smallest resonance frequency
//    which can be handled with the current memory allocation.
//

sampleType Comb::getMinFund(void) {
   return getSrate()/maxbuffsize;
}



//////////////////////////////
//
// Comb::getGain -- returns the comb filter's feedback gain.
//

sampleType Comb::getGain(void) {
   return inputs[1];
}



//////////////////////////////
//
// Comb::getReverbTime -- calculates the T60 reverberation from the 
//     current gain.
//

sampleType Comb::getReverbTime(void) {
   return -3.0 / (getFund() * log10(fabs(getGain())) );
}



//////////////////////////////
//
// Comb::getSignal -- returns the signal being fed into the comb filter.
//

sampleType Comb::getSignal(void) {
   return inputs[0];
}



//////////////////////////////
//
// Comb::output -- returns the current output value of the comb filtered
//     signal.
//

sampleType Comb::output(int channel) {
   return outputValue;
}



//////////////////////////////
//
// Comb::setDelaySamples -- sets the delay in samples.  Will not set the 
//     delay larger than the maximum allowed by setMinFund().
//

void Comb::setDelaySamples(int aDelay) {
   int newbuffsize = aDelay;
   if (newbuffsize == buffsize) return;
   if (newbuffsize <= maxbuffsize) {
      buffsize = newbuffsize;
      clear();
   } else {
      buffsize = maxbuffsize;
      clear();
   }
}



//////////////////////////////
//
// Comb::setFund -- resets the memory of the comb filter delay.
//     If the fundamental is larger than the maximum set with
//     the setMinFund(), then the resonance fundamental is 
//     limited to the value of the getMinFund() value.
//

void Comb::setFund(sampleType aFund) {
   setDelaySamples((int)(getSrate()/aFund + 0.5));
   clear();
}



//////////////////////////////
//
// Comb::setLoopTime -- sets the delay time in seconds.  Will not
//    exceed the maximum time allowed by setMinFund().
//

void Comb::setLoopTime(sampleType aLoopTime) {
   setDelaySamples((int)(getSrate()*aLoopTime + 0.5));
   clear();
}
   


//////////////////////////////
//
// Comb::setMinFund -- allocates the longest delay which will be 
//     needed in the comb filter.
//

void Comb::setMinFund(sampleType aMin) {
   maxbuffsize = (int)(getSrate()/aMin) + 10;  // extra for round-off avoidance
   circularQueue.setSize(maxbuffsize);
   if (buffsize > maxbuffsize) {
      buffsize = maxbuffsize;
   }
   clear();
}



//////////////////////////////
//
// Comb::setReverbTime -- calculates the gain necessary for the 
//     given T60 reverberation time.
//

void Comb::setReverbTime(sampleType aReverbTime) {
   connect(pow(0.001, 1.0/(getSrate()*getFund()*aReverbTime)), 1);
}



//////////////////////////////
//
// Comb::setGain -- sets the feedback gain of the comb filter.
//     stable values are in the range from [-1.0 .. 1.0]
//

void Comb::setGain(sampleType aGain) {
   connect(aGain, 1);
}



// md5sum: 90b1d66539d81553c14d47551be741bf Comb.cpp [20050403]