//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Fri Aug 18 21:51:09 PDT 2000
// Last Modified: Fri Aug 18 21:51:14 PDT 2000
// Filename:      ...sig/doc/examples/all/pitchdelac/pitchdelac.cpp
// Syntax:        C++; sig
//
// Description:   This program is an implementation of a pitch
//		  detection algorithm by Patrico de la Cuadra
//		  <pdelac@ccrma.stanford.edu>
//

#include "sig.h"
 
// function declarations:
void checkOptions  (Options& opts);
void example       (void);
void usage         (const char* command);
void analyze       (Array<double>& result, Array<double>* buffer);
void fill          (Array<double>* buffer, SoundFileIn& insound);
void printArray    (int frame, const Array<double>& anArray);

// global interface variables
double srate = 0;    // the sampling rate of the input soundfile
int framesize = 0;   // the number of samples in a primary frame
int harmonics = 0;   // the number of harmonics to analyze
int quietQ = 0;      // suppress status printing while program is running

////////////////////////////////////////////////////////////////////////////////

int main (int argc, char *argv[]) {
   Options options(argc, argv);
   checkOptions(options);

   SoundFileIn insound(options.getArgument(1));
   srate = insound.getSrate();

   double frames = (double)insound.getSamples() / framesize;
   int framecount;
   if ((int)frames - frames == 0.0) {
      framecount = (int)frames;
   } else {
      framecount = (int)frames + 1;
   }
 
   Array<double> buffer[harmonics];
   for (int j=0; j<harmonics; j++) {
      if (j == 0) {
         buffer[j].setSize(framesize);
      } else {
         buffer[j].setSize(framesize/(j+1) + 1);
      }
      buffer[j].allowGrowth(0);
      buffer[j].zero();
   }
   Array<double> result;
   result.setSize(framesize/harmonics + 1);
   result.allowGrowth(0);
   result.zero();

   for (int i=0; i<framecount; i++) {
      if (!quietQ) {
         cout << "Processing frame: " << i << endl;
      }
      fill(buffer, insound);  
cout << "Now analyzing..." << endl;
      analyze(result, buffer);
      printArray(i, result);
   }

   return 0;
}



////////////////////////////////////////////////////////////////////////////////



//////////////////////////////
//
// fill -- fill the signal buffers with data from the input soundfile.
//

void fill(Array<double>* buffer, SoundFileIn& insound) {
   double sample;
   for (int i=0; i<buffer[0].getSize(); i++) {
      insound.action();
      sample = insound.output(0);
      for (int j=0; j<harmonics; j++) {
         if (i % (j+1) == 0) {
            buffer[j][i/(j+1)] = sample;
         }
      }
   }
}



//////////////////////////////
//
// analyze -- Do frequency transform of the sound data and
//    generate a pitch array by multiplying the transforms
//    together.
//

void analyze(Array<double>& result, Array<double>* buffer) {
   Block<ComplexD> signal;
   Block<ComplexD> transform[harmonics];
   int i, j;
   for (i=0; i<harmonics; i++) {
      signal.setSize(buffer[i].getSize());
      for (j=0; j<signal.getSize(); j++) {
         signal[j].re() = buffer[i][j];
         signal[j].im() = buffer[i][j];
      }
      transform[i].setSize(signal.getSize());
      DFT(transform[i], signal);
   }

cout << "GOT HERE" << endl;
   // multiply adjacent harmonic spaces:
   for (i=0; i<transform[harmonics-1].getSize(); i++) {
      result[i] = 1.0;   
      for (j=0; j<harmonics; j++) {
         result[i] *= transform[j][i].abs();
      }
   }
}



//////////////////////////////
//
// printArray -- print a pitch analysis array.
//

void printArray(int frame, const Array<double>& anArray) {
   cout << "\n# FRAME = " << frame << "\n";
   for (int i=0; i<anArray.getSize(); i++) {
      cout << "\t" << anArray[i] << "\n"; 
   }
}



//////////////////////////////
//
// checkOptions -- make sure that all program options are ok and
//     setup interface variables.
//

void checkOptions(Options& opts) {
   opts.define("h|harmonics=i:5",    "Num of harmonics to consider");
   opts.define("f|framesize=i:1024", "Num of samples in fundamental frame");
   opts.define("q|quiet=b",          "Suppress printing of status information");
   opts.define("help=b");
   opts.define("author=b");
   opts.define("version=b");
   opts.define("example=b");
   opts.process();


   if (opts.getBoolean("help")) {
      usage(opts.getCommand());
      exit(0);
   }
   if (opts.getBoolean("example")) {
      example();
      exit(0);
   }
   if (opts.getBoolean("author")) {
      cout << "Written by Craig Stuart Sapp, "
           << "craig@ccrma.stanford.edu, August 2000" << endl;
      exit(0);
   }
   if (opts.getBoolean("version")) {
      cout << "pitchdelac version: Fri Aug 18 22:37:39 PDT 2000" << endl;
      cout << SIG_VERSION << endl;
      exit(0);
   }
   if (opts.getArgCount() != 1) {
      cout << "Error: must specify one input soundfile" << endl;
      usage(opts.getCommand());
      exit(1);
   }

   harmonics = opts.getInt("harmonics");
   framesize = opts.getInt("framesize");

   if (framesize < 64) {
      cout << "Error: frame size is too small: " << framesize << endl;
      exit(1);
   }
   if (framesize > 10000) {
      cout << "Error: frame size is too large: " << framesize << endl;
      exit(1);
   }
 
   if (harmonics < 1) {
      cout << "Error: harmonic count is too small: " << harmonics << endl;
      exit(1);
   }
   if (harmonics > 30) {
      cout << "Error: harmonic count is too large: " << harmonics << endl;
      exit(1);
   }
   if (framesize/harmonics < 10) {
      cout << "Error: too many harmonics for the given framesize" << endl;
      exit(1);
   }

   quietQ = opts.getBoolean("quiet");
}



//////////////////////////////
//
// example -- example usage of the program.
//

void example(void) {
   cout << 
   " To be written.                                              \n"
   << endl;
}



//////////////////////////////
//
// usage -- explaination about the program and its options.
//

void usage(const char* command) {
   cout << "\nUsage: " << command 
        << " [-f framesize][-h harmonics] soundfile\n";
   cout << "   Determines pitch in a soundfile.\n";
   cout << "   Options are:\n";
   cout << "      -f framesize = size of primary analysis frame\n";
   cout << "      -h harmonics = number of analysis frames per block\n";
   cout << "      -o frameoverlap = option not active\n";
   cout << "      --options a list of all options.\n";
   cout << endl;

}