//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Mon May  5 22:57:47 GMT-0800 1997
// Last Modified: Mon May  5 22:57:44 GMT-0800 1997
// Last Modified: Wed Oct 16 20:54:56 PDT 2002 (added soundfile input)
// Filename:      ...sig/src/Filter/WaveTable/WaveTable.cpp
// Syntax:        C++ 
// $Smake:        cc -Wall -g -c %b.cc -I../../../include && rm -f %b.o
//

#include "Wavetable.h"
#include "SoundHeader.h"
#include "SoundFileIn.h"

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


//////////////////////////////
//
// WaveTable::WaveTable
//

WaveTable::WaveTable(int size) {
   setName("WaveTable");
   outputValue = 0;
   interp = 'L';
   repeat = 0;
   index = 0.0;
   waveTable.setSize(size);
   brandname = FILTER;
   magicNumber = (double)size/getSrate();
   forward();
}



//////////////////////////////
//
// WaveTable::~WaveTable
//

WaveTable::~WaveTable() { }



//////////////////////////////
//
// WaveTable::action
//

void WaveTable::action(void) { 
   if (inputs[1] >= 0) {
      index += pow(2.0, inputs[0] / 12.0);
   } else {
      index -= pow(2.0, inputs[0] / 12.0);
   }
   if (index >= waveTable.getSize()) {
      index -= waveTable.getSize();
      repeat++;
   } else if (index < 0) {
      index += waveTable.getSize();
      repeat++;
   }
   if (interp == 'C') {
      outputValue = waveTable[(int)index];
   } else {
      int intval = (int)index;
      double fract = index - intval;
      if (fract == 0.0) {
         outputValue = waveTable[(int)index];
      } else {
         double b = waveTable[intval];
         double a;
         if (intval != 0) {
            a = waveTable[intval - 1];
         } else {
            a = waveTable[waveTable.getSize() - 1];
         }
         outputValue = (b - a) * fract + a;
      }
   }
}



//////////////////////////////
//
// WaveTable::getRepeat -- return the number of times the wavetable
//     has be cycled through.
//

int WaveTable::getRepeat(void) {
   return repeat;
}



//////////////////////////////
//
// WaveTable::normalize
//	default value: maxAmp = 1.0
//

void WaveTable::normalize(sampleType maxAmp) {
   int i;
   sampleType normalizer = 0;
   for (i=0; i<waveTable.getSize(); i++) {
      if (fabs(waveTable[i]) > normalizer) {
         normalizer = fabs(waveTable[i]);
      }
   }
   normalizer = normalizer / maxAmp;
   for (i=0; i<waveTable.getSize(); i++) {
      waveTable[i] = waveTable[i] / normalizer;
   }
}



//////////////////////////////
//
// WaveTable::output
//

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



//////////////////////////////
//
// WaveTable::reverse -- reverse the wavetable
//

void WaveTable::reverse(void) {
   inputs.setDefault(1, -1.0);
}



//////////////////////////////
//
// WaveTable::forward -- reverse the wavetable
//

void WaveTable::forward(void) {
   inputs.setDefault(1, 1.0);
}



/////////////////////////////
//
// WaveTable::setConstantInterp --
//

void WaveTable::setConstantInterp(void) { 
   interp = 'C';
}



/////////////////////////////
//
// WaveTable::setConstantInterp --
//

void WaveTable::setLinearInterp  (void) { 
   interp = 'L';
}



//////////////////////////////
//
// WaveTable::setSize
//

void WaveTable::setSize(long aSize) {
   waveTable.setSize(aSize);
}



//////////////////////////////
//
// WaveTable::setTable
//

void WaveTable::setTable(sampleType *anArray, int aSize) {
   waveTable.setSize(aSize);
   int i;
   for (i=0; i<aSize; i++) {
      waveTable[i] = anArray[i];
   }
}

void WaveTable::setTable(Array<sampleType> anArray) {
   waveTable.setSize(anArray.getSize());
   int i;
   for (i=0; i<anArray.getSize(); i++) {
      waveTable[i] = anArray[i];
   }
}



//////////////////////////////
//
// WaveTable::setTableFromFile
//

void WaveTable::setTableFromFile(char* filename) {
   SoundHeader header(filename);
   int samples = header.getSamples();
   setSize(samples);
   SoundFileIn insoundfile(filename);
   int i;
   for (i=0; i<samples; i++) {
      insoundfile.tick(i);
      waveTable[i] = insoundfile.output(0);  // monophonic only for now
   }
}



//////////////////////////////
//
// WaveTable::setTableHarmonics
//

void WaveTable::setTableHarmonics(char* harmonicString) {
   cerr << "Isn't implemented yet" << endl;
   exit(1);
}

void WaveTable::setTableHarmonics(SigCollection<Partial> partialArray) {
   cerr << "Isn't implemented yet" << endl;
   exit(1);
}



//////////////////////////////
//
// WaveTable::setTableRamp
//	default value tableSize = -1
//

void WaveTable::setTableRamp(long tableSize) {
   if (tableSize > 0) {
      setSize(tableSize);
   }

   sampleType increment = 2.0/(waveTable.getSize() - 1.0);
   sampleType currentValue = -1.0;
   for (int i=0; i<waveTable.getSize(); i++) {
      waveTable[i] = currentValue;
      currentValue += increment;
   }
}



//////////////////////////////
//
// WaveTable::setTableSinewave
//	default value tableSize = -1
//

void WaveTable::setTableSinewave(long tableSize) {
   if (tableSize > 0) {
      setSize(tableSize);
   }

   for (int i=0; i<waveTable.getSize(); i++) {
      waveTable[i] = sin(2 * 3.14159 * i / waveTable.getSize());
   }
}



//////////////////////////////
//
// WaveTable::setTableSquare
//	default value tableSize = -1
//

void WaveTable::setTableSquare(long tableSize) {
   if (tableSize > 0) {
      setSize(tableSize);
   }

   int i;
   for (i=0; i<waveTable.getSize()/2; i++) {
      waveTable[i] = 1.0;
   }
   for (i=waveTable.getSize()/2 + 1; i<waveTable.getSize(); i++) {
      waveTable[i] = -1.0;
   }
}



//////////////////////////////
//
// WaveTable::setTableTriangle
//	default value tableSize = -1
//

void WaveTable::setTableTriangle(long tableSize) {
   if (tableSize > 0) {
      setSize(tableSize);
   }

   int i;
   sampleType increment;
   sampleType currentValue = -1.0;

   increment = 2.0/(waveTable.getSize()/2 - 1.0);
   for (i=0; i<waveTable.getSize()/2; i++) {
      waveTable[i] = currentValue;
      currentValue += increment;
   }

   increment = -1.0/((waveTable.getSize()-waveTable.getSize()/2) - 1.0);
   currentValue = 1.0 - increment;
   for (i=waveTable.getSize()/2 + 1; i<waveTable.getSize(); i++) {
      waveTable[i] = currentValue;
      currentValue += increment;
   }

cerr << "In triangle: this value should be -1.0: " << currentValue << endl;
}



//////////////////////////////
//
// WaveTable::shift
//

void WaveTable::shift(long shiftAmount) {
   cerr << "Isn't implemented yet" << endl;
   exit(1);
}




// md5sum: 9ff575aedbbbbf86a3a1dd451d19dea1 Wavetable.cpp [20050403]