spec_05.cc

这是一个从音频信号里提取特征参量的程序

// file: $isip/class/algo/Spectrum/spec_05.cc
// version: $Id: spec_05.cc,v 1.21 2002/07/02 23:20:05 picone Exp $
//

// isip include files
//
#include "Spectrum.h"

// method: apply
//
// arguments:
//  Vector<AlgorithmData>& output: (output) output data
//  const Vector< CircularBuffer<AlgorithmData> >& input: (input) input data
//
// return: a boolean value indicating status
//
// this method calls the appropriate computation methods
//
boolean Spectrum::apply(Vector<AlgorithmData>& output_a,
			const Vector< CircularBuffer<AlgorithmData> >&
			input_a) {

  // determine the number of input channels and force the output to be
  // that number
  //
  long len = input_a.length();
  output_a.setLength(len);

  // start the debugging output
  //
  displayStart(this);

  // accumulate a result status -- if compute method returns false
  // this apply method should return false
  //  
  boolean res = true;
  
  // loop over the channels and call the compute method
  //
  for (long c = 0; c < len; c++) {

    // display the channel number
    //
    displayChannel(c);

    if (implementation_d == MAGNITUDE) {

      // call AlgorithmData::makeVectorFloat to force the output vector for
      // this channel to be a VectorFloat.
      // call AlgorithmData::getVectorFloat on the input for this channel
      // to check that the input is already a VectorFloat and return
      // that vector.
      //          
      res &= compute(output_a(c).makeVectorFloat(),
		     input_a(c)(0).getVectorFloat(),
		     input_a(c)(0).getCoefType(), c);
    }

    else if (implementation_d == COMPLEX) {

      // call AlgorithmData::makeComplexVectorFloat to force the output
      // vector for this channel to be a VectorFloat.
      // call AlgorithmData::getVectorFloat on the input for this channel to
      // check that the input is already a VectorFloat and return that
      // vector.
      //                
      res &= compute(output_a(c).makeVectorComplexFloat(),
		     input_a(c)(0).getVectorFloat(),
		     input_a(c)(0).getCoefType(), c);
    }

    // else: error unknown implementation
    //
    else {
      return Error::handle(name(), L"apply", ERR_UNKIMP,
			   __FILE__, __LINE__);
    }    

    // set the coefficient type of output
    //
    output_a(c).setCoefType(AlgorithmData::SPECTRUM);
  }
  
  // finish the debugging output
  //
  displayFinish(this);

  // exit gracefully
  //
  return res;  
}

// method: compute
//
// arguments:
//  VectorFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//  AlgorithmData::COEF_TYPE input_coef_type: (input) type of input
//  long index: (input) channel number
//
// return: a boolean value indicating status
//
// this method computes the magnitude spectrum of the input signal
//
boolean Spectrum::compute(VectorFloat& output_a,
			  const VectorFloat& input_a,
			  AlgorithmData::COEF_TYPE input_coef_type_a,
			  long index_a) {

  // declare local variables
  //
  boolean status = false;
  
  // brach on algorithm
  //
  // algorithm: FOURIER
  //
  if (algorithm_d == FOURIER) {

    // coefficient type: SIGNAL
    //
    if (input_coef_type_a == AlgorithmData::SIGNAL) {

      // calculate corresponding fourier transform compute method
      //
      status = computeFourierMag(output_a, input_a);
    }

    // else: error unknown coefficient type
    //
    else {
      status = Error::handle(name(), L"compute",
			     ERR_UNKTYP, __FILE__, __LINE__);
    }      
  }

  // check known but unsupported algorithms
  //
  else if (algorithm_d == MAXIMUM_ENTROPY) {

    // coefficient type: REFLECTION
    //
    if (input_coef_type_a == AlgorithmData::REFLECTION) {

      // calculate corresponding fourier transform compute method
      //
      status = computeReflectionMag(output_a, input_a, dyn_range_d);
    }

    // coefficient type: PREDICTION
    //
    else if (input_coef_type_a == AlgorithmData::PREDICTION) {

      // calculate corresponding fourier transform compute method
      //
      status = computePredictionMag(output_a, input_a);
    }

    // coefficient type: CORRELATION
    //
    else if (input_coef_type_a == AlgorithmData::CORRELATION) {

      // calculate corresponding fourier transform compute method
      //
      status = computeCorrelationMag(output_a, input_a, dyn_range_d);
    }        

    // else: error unknown coefficient type
    //
    else {
      status = Error::handle(name(), L"compute",
			     ERR_UNKTYP, __FILE__, __LINE__);
    }
  }

  // else: error unknown algorithm
  //
  else {
    status = Error::handle(name(), L"compute",
			   ERR_UNKALG, __FILE__, __LINE__);
  }

  // possibly display the data
  //
  display(output_a, input_a, name());

  // exit gracefully
  //
  return status;  
}

// method: compute
//
// arguments:
//  VectorComplexFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//  AlgorithmData::COEF_TYPE input_coef_type: (input) type of input
//  long index: (input) channel number
//
// return: a boolean value indicating status
//
// this method computes the complex spectrum of the input signal
//
boolean Spectrum::compute(VectorComplexFloat& output_a,
			  const VectorFloat& input_a,
			  AlgorithmData::COEF_TYPE input_coef_type_a,
			  long index_a) {

  // declare local variables
  //
  boolean status = false;
  
  // brach on algorithm
  //
  // algorithm: FOURIER
  //
  if (algorithm_d == FOURIER) {

    // coefficient type: SIGNAL
    //
    if (input_coef_type_a == AlgorithmData::SIGNAL) {

      // calculate corresponding fourier transform compute method
      //
      status = computeFourierComplex(output_a, input_a);
    }

    // else: error unknown coefficient type
    //
    else {
      status = Error::handle(name(), L"compute",
			     ERR_UNKTYP, __FILE__, __LINE__);
    }      
  }

  // check known but unsupported algorithms
  //
  else if (algorithm_d == MAXIMUM_ENTROPY) {

    // coefficient type: REFLECTION
    //
    if (input_coef_type_a == AlgorithmData::REFLECTION) {

      // calculate corresponding fourier transform compute method
      //
      status = computeReflectionComplex(output_a, input_a);
    }

    // coefficient type: PREDICTION
    //
    else if (input_coef_type_a == AlgorithmData::PREDICTION) {

      // calculate corresponding fourier transform compute method
      //
      status = computePredictionComplex(output_a, input_a);
    }

    // coefficient type: CORRELATION
    //
    else if (input_coef_type_a == AlgorithmData::CORRELATION) {

      // calculate corresponding fourier transform compute method
      //
      status = computeCorrelationComplex(output_a, input_a);
    }        

    // else: error unknown coefficient type
    //
    else {
      status = Error::handle(name(), L"compute",
			     ERR_UNKTYP, __FILE__, __LINE__);
    }
  }

  // else: error unknown algorithm
  //
  else {
    status = Error::handle(name(), L"compute",
			   ERR_UNKALG, __FILE__, __LINE__);
  }

  // possibly display the data
  //
  display(output_a, input_a, name());

  // exit gracefully
  //
  return status;  
}

// method: computeReflectionMag
//
// arguments:
//  VectorFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//  double range: (input) dynamic range
//
// return: a boolean value indicating status
//
// this method computes the magnitude spectrum of the input signal for
// REFLECTION implementation type
//
boolean Spectrum::computeReflectionMag(VectorFloat& output_a,
				       const VectorFloat& input_a,
				       double range_a) {


  // declare local variables
  //
  Prediction predc;
  VectorFloat pred_coeff;
  VectorFloat refl_coeff(input_a);

  // set the order of the prediction coefficients
  //
  long order = refl_coeff.length() + 1;
  pred_coeff.setLength(order);
  
  // determine the prediction coefficients form the reflection coefficients
  //
  predc.set(Prediction::REFLECTION, Prediction::STEP_DOWN, order, range_a);
  predc.compute(pred_coeff, refl_coeff, AlgorithmData::REFLECTION);

  // negate the predictor coefficients
  //
  pred_coeff.neg();

  // compute the magnitude spectrum
  //
  computeFourierMag(output_a, pred_coeff);
  
  // exit gracefully
  //
  return true;
}

// method: computePredictionMag
//
// arguments:
//  VectorFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//
// return: a boolean value indicating status
//
// this method computes the magnitude spectrum of the input signal for
// PREDICTION implementation type
//
boolean Spectrum::computePredictionMag(VectorFloat& output_a,
				       const VectorFloat& input_a) {

  // declare local variables
  //
  VectorFloat pred_coeff(input_a);

  // negate the predictor coefficients
  //
  pred_coeff.neg();

  // compute the magnitude spectrum
  //
  computeFourierMag(output_a, pred_coeff);
  
  // exit gracefully
  //
  return true;
}

// method: computeCorrelationMag
//
// arguments:
//  VectorFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//  double range: (input) dynamic range
//
// return: a boolean value indicating status
//
// this method computes the magnitude spectrum of the input signal for
// CORRELATION implementation type
//
boolean Spectrum::computeCorrelationMag(VectorFloat& output_a,
					const VectorFloat& input_a,
					double range_a) {

  // declare local variables
  //
  Prediction predc;
  VectorFloat pred_coeff;
  VectorFloat auto_coeff(input_a);

  // set the order of the prediction coefficients
  //
  long order = auto_coeff.length();
  pred_coeff.setLength(order);

  // compute the prediction coefficients from the autocorrelation coefficients
  //
  predc.set(Prediction::AUTOCORRELATION, Prediction::DURBIN, order, range_a);
  predc.compute(pred_coeff, auto_coeff, AlgorithmData::CORRELATION);

  // negate the predictor coefficients
  //
  pred_coeff.neg();

  // compute the magnitude spectrum
  //
  computeFourierMag(output_a, pred_coeff);
  
  // exit gracefully
  //
  return true;
}

// method: computeFourierMag
//
// arguments:
//  VectorFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//
// return: a boolean value indicating status
//
// this method computes the magnitude spectrum of the input signal for
// FOURIER implementation type
//
boolean Spectrum::computeFourierMag(VectorFloat& output_a,
				    const VectorFloat& input_a) {

  // compute the complex spectrum
  //
  VectorComplexFloat tmp;
  computeFourierComplex(tmp, input_a);
  output_a.setLength(tmp.length());

  // compute the magnitude spectrum:
  //  magnitude spectrum = sqrt(real^2 + imag^2)
  //
  for (long i = 0; i < tmp.length(); i++) {
    Float sq_spec;
    Float real(tmp(i).real());
    Float imag(tmp(i).imag());
    sq_spec = real.square() + imag.square();
    output_a(i) = sq_spec.sqrt();
  }
  
  // exit gracefully
  //
  return true;
}

// method: computeReflectionComplex
//
// arguments:
//  VectorComplexFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//  double range: (input) dynamic range
//
// return: a boolean value indicating status
//
// this method computes the complex spectrum of the input signal for
// REFLECTION implementation type
//
boolean Spectrum::computeReflectionComplex(VectorComplexFloat& output_a,
					   const VectorFloat& input_a,
					   double range_a) {

  // declare local variables
  //
  Prediction predc;
  VectorFloat pred_coeff;
  VectorFloat refl_coeff(input_a);

  // set the order of the prediction coefficients
  //
  long order = refl_coeff.length() + 1;
  pred_coeff.setLength(order);
  
  // determine the prediction coefficients form the reflection coefficients
  //
  predc.set(Prediction::REFLECTION, Prediction::STEP_DOWN, order, range_a);
  predc.compute(pred_coeff, refl_coeff, AlgorithmData::REFLECTION);

  // negate the predictor coefficients
  //
  pred_coeff.neg();
  
  // compute the magnitude spectrum
  //
  computeFourierComplex(output_a, pred_coeff);

  // exit gracefully
  //
  return true;
}

// method: computePredictionComplex
//
// arguments:
//  VectorComplexFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//
// return: a boolean value indicating status
//
// this method computes the complex spectrum of the input signal for
// PREDICTION implementation type
//
boolean Spectrum::computePredictionComplex(VectorComplexFloat& output_a,
					   const VectorFloat& input_a) {

  // declare local variables
  //
  VectorFloat pred_coeff(input_a);

  // negate the predictor coefficients
  //
  pred_coeff.neg();
  
  // compute the magnitude spectrum
  //
  computeFourierComplex(output_a, pred_coeff);
  
  // exit gracefully
  //
  return true;
}

// method: computeCorrelationComplex
//
// arguments:
//  VectorComplexFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//  double range: (input) dynamic range
//
// return: a boolean value indicating status
//
// this method computes the complex spectrum of the input signal for
// CORRELATION implementation type
//
boolean Spectrum::computeCorrelationComplex(VectorComplexFloat& output_a,
					    const VectorFloat& input_a,
					    double range_a) {

  // declare local variables
  //
  Prediction predc;
  VectorFloat pred_coeff;
  VectorFloat auto_coeff(input_a);

  // set the order of the prediction coefficients
  //
  long order = auto_coeff.length();
  pred_coeff.setLength(order);

  // compute the prediction coefficients from the autocorrelation coefficients
  //
  predc.set(Prediction::AUTOCORRELATION, Prediction::DURBIN, order, range_a);
  predc.compute(pred_coeff, auto_coeff, AlgorithmData::CORRELATION);

  // negate the predictor coefficients
  //
  pred_coeff.neg();
  
  // compute the magnitude spectrum
  //
  computeFourierComplex(output_a, pred_coeff);
  
  // exit gracefully
  //
  return true;
}

// method: computeFourierComplex
//
// arguments:
//  VectorComplexFloat& output: (output) spectrum
//  const VectorFloat& input: (input) signal
//
// return: a boolean value indicating status
//
// this method computes the spectrum of the input signal for FOURIER
// algorithm type
//
boolean Spectrum::computeFourierComplex(VectorComplexFloat& output_a,
					const VectorFloat& input_a) {

  // call FourierTransform compute method with a user-specified order
  //
  return ft_d.compute(output_a, input_a);
}