// file: calculate_lpc.cc 
//
// this driver program calculates the spectrum of a signal produced by a
// linear prediction model and one produced by a DFT model.
//

// system include files
//
#include <stdio.h>
#include <math.h>
#include <string.h>

// local include files
//
#include "global_constants.h"
#include "calculate_lpc_constants.h"
#include "calculate_lpc.h"

// main program
//
main (int argc, char** argv) {

  // declare various parameters for lpc calculation
  //
  char* datafile = (char*)NULL;
  float frame_size = CLPC_DEFAULT_FRAME_SIZE;
  float win_size = CLPC_DEFAULT_WIN_SIZE;
  float win_center_time = CLPC_DEFAULT_WIN_CENTER;
  float sample_freq = CLPC_DEFAULT_SAMPLE_FREQ;
  int num_chans = CLPC_DEFAULT_NUM_CHANS;
  float preemp_val = CLPC_DEFAULT_PREEMP_VAL;
  int win_type = CLPC_DEFAULT_WIN_TYPE;
  int lp_order = CLPC_DEFAULT_LP_ORDER;
  int dft_order = CLPC_DEFAULT_DFT_ORDER;
  int debug_mode = CLPC_DEFAULT_DEBUG_MODE;
  
  // get the command line arguments
  //
  if (get_parameters_cc(datafile, frame_size, win_size, win_center_time,
			sample_freq, num_chans, preemp_val, win_type,
			lp_order, dft_order, debug_mode, argv, argc) != TRUE) {
    fprintf(stdout, "Error in command line arguments\n");
    return ERROR;
  }

  if (check_parameters_cc(datafile, frame_size, win_size, win_center_time,
			  sample_freq, num_chans, preemp_val, win_type,
			  lp_order, dft_order, debug_mode) != TRUE) {
    fprintf(stdout, "Invalid parameter value\n");
    return ERROR;
  }

  // calculate the number of samples per frame and per window
  //
  int samples_per_win = calculate_num_samples_cc (win_size, sample_freq);
  int win_center_sample = calculate_num_samples_cc (win_center_time,
						    sample_freq);
  
  // calculate end file sample
  //
  int end_file_sample = calculate_end_sample_cc(datafile, sample_freq,
						num_chans);
  // start and end sample of a window
  //
  int offset_samples = int ( rint(samples_per_win / 2) );
  int start_sample = int ( rint(win_center_sample - offset_samples) );
  int end_sample = int ( rint(win_center_sample + offset_samples) );

  if (debug_mode > DEBUG_FULL) {
    fprintf(stdout, "number of samples per window: %d\n", samples_per_win);
    fprintf(stdout, "start sample: %d\n", start_sample);
    fprintf(stdout, "end sample: %d\n", end_sample);
    fprintf(stdout, "end file sample: %d\n", end_file_sample);
    fprintf(stdout, "\n");
  }
  
  // declare and initialize buffer to hold a window of the signal
  //
  int num_samples = num_chans * samples_per_win;
  float* signal_window = new float[num_samples];
  memset(signal_window, 0, sizeof(float) * num_samples);
  
  // previous value of a frame
  //
  float* prev_sig_val = new float[num_chans];
  memset(prev_sig_val, 0, sizeof(float) * num_chans);

  // read in the signal center at win_center_time
  //
  if (read_signal_cc(signal_window, num_chans, start_sample, end_sample,
		     end_file_sample, datafile, debug_mode) != TRUE) {
    fprintf(stdout, "Unable to read window of signal\n");
    return ERROR;
  }

  // debias the signal
  //
  debias_signal_cc(signal_window, samples_per_win, num_chans, debug_mode);

  // pre-emphasize the signal
  //
  pre_emphasize_signal_cc(signal_window, prev_sig_val, samples_per_win,
			  num_chans, preemp_val, debug_mode);

  // window the signal
  //
  window_signal_cc(signal_window, samples_per_win, num_chans, win_type,
		   debug_mode);

  // declare and initialize the dft and lp buffer
  //
  float** dft_signal = new float*[num_chans];
  float** lp_signal = new float*[num_chans];
  
  for (int chan = 0; chan < num_chans; chan++) {
    dft_signal[chan] = new float[dft_order];
    memset(dft_signal[chan], 0, sizeof(float) * dft_order);
    lp_signal[chan] = new float[samples_per_win];
    memset(lp_signal[chan], 0, sizeof(float) * samples_per_win);
  }

  // declare and initialize lp gain buffer
  //
  float* lp_gain = new float[num_chans];
  memset(lp_gain, 1, sizeof(float) * num_chans);

  // compute the DFT magnitude spectrum in dB
  // 
  calculate_dft_cc(dft_signal, signal_window, samples_per_win, num_chans,
		   dft_order, debug_mode);

  // print out the dft of the signal
  //
  print_buffer_cc(dft_signal, num_chans, dft_order, sample_freq);

  // compute the LPC spectrum in dB
  //
  calculate_lp_cc(lp_signal, lp_gain, signal_window, samples_per_win,
		  num_chans, lp_order, debug_mode);

  // print out the lpc of the signal
  //
  print_buffer_cc(lp_signal, num_chans, samples_per_win, sample_freq);

  // free up space
  //
  if (datafile != (char*)NULL) {
    delete [] datafile;
    datafile = (char*)NULL;
  }

  if (signal_window != (float*)NULL) {
    delete [] signal_window;
    signal_window = (float*)NULL;
  }
  
  if (prev_sig_val != (float*)NULL) {
    delete [] prev_sig_val;
    prev_sig_val = (float*)NULL;
  }

  if (dft_signal != (float**)NULL) {
    for (int chan = 0; chan < num_chans; chan++) {
      if (dft_signal[chan] != (float*)NULL) {
	delete [] dft_signal[chan];
	dft_signal[chan] = (float*)NULL;
      }
    }
    delete [] dft_signal;
    dft_signal = (float**)NULL;
  }

  if (lp_signal != (float**)NULL) {
    for (int chan = 0; chan < num_chans; chan++) {
      if (lp_signal[chan] != (float*)NULL) {
	delete [] lp_signal[chan];
	lp_signal[chan] = (float*)NULL;
      }
    }
    delete [] lp_signal;
    lp_signal = (float**)NULL;
  }

  if (lp_gain != (float*)NULL) {
    delete [] lp_gain;
    lp_gain = (float*)NULL;
  }
  
  // exit gracefully
  //
  return NO_ERROR;
}