/* tone.h
   Simple Mandarin tone recognizer using pitch track

   Jim Gilsinan IV
   gilsinan@post.harvard.edu
   http://www.fas.harvard.edu/~gilsinan/

   Senior Thesis
   Harvard University
   2000-2001

*/

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

#include "tone.h"
#include "syllable.h"
#include "regression.h"

#define STRAW_MAN_THRESHOLD 0.2

int main ( int argc, char **argv )
{
  int sample_count, i, j;
  FILE * pitch_track_file;
  FILE * tone_template_file;
  double ** pitch_track;
  double ** standard_pitch_track;
  double *tone_template[4];
  double standard_tone_template[4][STANDARD_LEN];
  int tone_length[4];
  double differences[4];
  double a, b1, b2;
  int *syllable_offset;
  int *template_offset;
  int sample_syllable_count,
      template_syllable_count;
  int reg;
  int cep;             // cepstral regions to divide sample into

  printf ("Simple Mandarin Tone Recognizer\n");

  if (argc < 5) {
    printf ("Usage: tone <test pitchtrack file> <template pitchtrack file>\n");
    printf ("            <regression> <cepstral regions per syllable>\n\n");
    printf ("Regressions: -1= straw man\n");
    printf ("             0 = direct compare\n");
    printf ("             1 = linear\n");
    printf ("             2+= polynomial\n");
    exit ( 0 );
  }

  sscanf(argv[3], "%d", &reg);
  sscanf(argv[4], "%d", &cep);

  if (cep < 1 || cep > 20) {
    printf("Cepstral areas must be between 1 and 20, inclusive.  Defaulting to 4.\n");
    cep = 4;
  }

  printf("Using regression method %d with %d cepstral regions\n",
	 reg, cep);

  printf("Opening file %s...", argv[1]);

  if (!(pitch_track_file = fopen (argv[1], "r"))) {
    printf("Error opening file: %s\n", argv[1]);
	exit ( 1 );
  }
  
  printf("done.\nProcessing pitch track...\n");

  syllable_offset = detect_syllables(pitch_track_file, &sample_syllable_count);
  printf("Found %d syllables in input...\n", sample_syllable_count);

  pitch_track = malloc(sample_syllable_count * sizeof(double*));
  standard_pitch_track = malloc(sample_syllable_count * sizeof(double*));

  for (i = 0; i < sample_syllable_count; i++)
    standard_pitch_track[i] = malloc(STANDARD_LEN * sizeof(double));


  // process all syllables in pitch track

  for (i = 0; i < sample_syllable_count; i++) {
    pitch_track[i] = get_syllable(pitch_track_file,
				  &sample_count, syllable_offset[i]);

    printf("%d samples in syllable %d...\n", sample_count, i+1);
    normalize_syllable(pitch_track[i], sample_count);
    standardize_syllable( pitch_track[i], sample_count,
			  standard_pitch_track[i] );
  }

  printf("\n");

  printf("Gathering tone template data...\n");

  if (!(tone_template_file = fopen (argv[2], "r"))) {
    printf("Error opening template pitch track: %s\n", argv[2]);
    exit ( 1 );
  }

  template_offset = detect_syllables(tone_template_file,
				   &template_syllable_count);

  if (template_syllable_count != 4) {
    printf("Sample syllable pitch track doesn't contain 4 syllables!\n");
    exit(1);
  }

  // process templates

  for (i = 0; i < 4; i++ ) {
    tone_template[i] = get_syllable(tone_template_file, &tone_length[i],
				    template_offset[i]);
    normalize_syllable(tone_template[i], tone_length[i]);

    standardize_syllable( tone_template[i],
			  tone_length[i], standard_tone_template[i] );
  }

  // straw man?
  // detect tone based on ideal shape of syllable
  // described in more detail in thesis write up

  if (reg == -1) {

    for (j = 0; j < sample_syllable_count; j++) {

      linear_regression(standard_pitch_track[j], 0, STANDARD_LEN/2,
			&a, &b1);

      linear_regression(standard_pitch_track[j], STANDARD_LEN/2,
			STANDARD_LEN, &a, &b2);

      if (b1 < -STRAW_MAN_THRESHOLD && b2 > STRAW_MAN_THRESHOLD) {
	printf("Syllable %d has slopes %f and %f and is tone 3\n",
	       j+1, b1, b2);
	continue;
      }

      linear_regression(standard_pitch_track[j], 0,
			STANDARD_LEN, &a, &b1);

      printf("Syllable %d has slope %f and is tone ",
	     j+1, b1);

      if (b1 > STRAW_MAN_THRESHOLD)
	printf("2\n");
      else if (b1 < -STRAW_MAN_THRESHOLD)
	printf("4\n");
      else
	printf("1\n");
    }

    exit(0);

  }

  // compare all syllables to templates

  for (j = 0; j < sample_syllable_count; j++) {

//    printf ("Syllable %d tone correlations: [", j+1);

    for (i = 0; i < 4; i++) {

      differences[i] = compare_pitch( standard_pitch_track[j],
				      standard_tone_template[i], reg, cep );
      printf("%f,", differences[i]);
    }
	printf("\n");
//printf("]\nDetected tone: %d\n", get_tone(differences));
  }

  exit ( 0 );
}

int get_tone ( double * differences )
{
  if (differences[0] < differences[1] &&
      differences[0] < differences[2] &&
      differences[0] < differences[3] )
    return ( 1 );

  if (differences[1] < differences[2] &&
      differences[1] < differences[3] )
    return ( 2 );

  if (differences[2] < differences[3] )
    return ( 3 );

  return ( 4 );
}

// compare syllables to templates, given desired regression / cepstral regions

double compare_pitch (double *in, double *template, int reg, int cep)
{
  double difference = 0;
  int i, j, k;

  double a, b1, b2;  // for linear reg
  
  double * coeffs_samp;    // for polynomial regression
  double * coeffs_temp;

  switch (reg) {

    // direct
  
  case 0:
    for ( i = 0; i < STANDARD_LEN; i++ )
      difference += fabsf(in[i] - template[i]);
    break;
    
    // linear
    
  case 1:
    for ( i = 0; i < cep; i++) {
      linear_regression(template, i * (STANDARD_LEN / cep),
			(i + 1) * (STANDARD_LEN / cep), &a, &b1);
      
      linear_regression(in, i * (STANDARD_LEN / cep),
			(i + 1) * (STANDARD_LEN / cep), &a, &b2);
      
      // printf("a: %f, b: %f\n", a, b);
      
      //    difference += linear_fit(in, i * (STANDARD_LEN / cep),
      //		               (i + 1) * (STANDARD_LEN / cep), a, b);
      
      difference += fabsf(b1 - b2);
    }

    break;

    // polynomial

  default:

    coeffs_samp = malloc((reg + 1) * sizeof(double));
    coeffs_temp = malloc((reg + 1) * sizeof(double));
    
    for ( i = 0; i < cep; i++) {
      polynomial_regression(reg, template, i * (STANDARD_LEN / cep),
			    (i + 1) * (STANDARD_LEN / cep), coeffs_temp);

      polynomial_regression(reg, in, i * (STANDARD_LEN / cep),
			    (i + 1) * (STANDARD_LEN / cep), coeffs_samp);

      /*
       * Figure out area between template best-fit poly
       * and sample best fit poly, using sum of differences.
       */
      
      for (k = 0; k < STANDARD_LEN / cep; k++)
	for (j = 1; j <= reg; j++)
	  difference += fabsf(coeffs_temp[j] * pow(k,j) -
			      coeffs_samp[j] * pow(k,j));

    }

    break;
  }
  
  return difference;
}