cep_05.cc

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

//
boolean Cepstrum::computeIdctT2Float(VectorFloat& cepstrum_a,
				     const VectorFloat& logspectrum_a) {
  
  // check the algorithm and implementation
  //
  if ((algorithm_d = IDCT) && (implementation_d != TYPE_II)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }

  // declare local variable
  //
  long comp_num_coeffs = order_d + (long)1;
  
  // compute the order
  //
  Long order;
  order.max(comp_num_coeffs, logspectrum_a.length());
  
  // setup the algorithm
  //
  if (!ft_d.setAlgorithm(FourierTransform::DCT)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // setup the implementation
  //
  if (!ft_d.setImplementation(FourierTransform::TYPE_II)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the direction
  //
  if (!ft_d.setDirection(FourierTransform::INVERSE)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the resolution
  //
  if (!ft_d.setResolution(FourierTransform::FIXED)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the input length (order of IDCT)
  //
  if (!ft_d.setInputLength(order)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the output length
  //
  if (!ft_d.setOutputLength(comp_num_coeffs)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // call compute method of fourier transform
  //
  if (!ft_d.compute(cepstrum_a, logspectrum_a)) {
    return Error::handle(name(), L"computeIdctT2Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // output debugging information
  //
  if (debug_level_d >= Integral::ALL) {
    cepstrum_a.debug(L"cepstrum");
  }
  
  // exit gracefully
  //
  return true;
}

// method: computeIdctT3Float
//
// arguments:
//  VectorFloat& cepstrum: (output) cepstral coefficients
//  const VectorFloat& logspectrum: (input) input log magnitude spectrum
//
// return: a boolean value indicating status
//
// this method gives the cepstral coefficients for given input log
// magnitude spectrum using IDCT algorithm and TYPE_III implementation
//
boolean Cepstrum::computeIdctT3Float(VectorFloat& cepstrum_a,
				      const VectorFloat& logspectrum_a) {
  
  // check the algorithm and implementation
  //
  if ((algorithm_d = IDCT) && (implementation_d != TYPE_III)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }

  // declare local variable
  //
  long comp_num_coeffs = order_d + (long)1;

  // compute the order
  //
  Long order;
  order.max(comp_num_coeffs, logspectrum_a.length());
  
  // setup the algorithm
  //
  if (!ft_d.setAlgorithm(FourierTransform::DCT)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // setup the implementation
  //
  if (!ft_d.setImplementation(FourierTransform::TYPE_III)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the direction
  //
  if (!ft_d.setDirection(FourierTransform::INVERSE)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the resolution
  //
  if (!ft_d.setResolution(FourierTransform::FIXED)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the input length (order of computeIdct)
  //
  if (!ft_d.setInputLength(order)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the output length
  //
  if (!ft_d.setOutputLength(comp_num_coeffs)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // call compute method of fourier transform
  //
  if (!ft_d.compute(cepstrum_a, logspectrum_a)) {
    return Error::handle(name(), L"computeIdctT3Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // output debugging information
  //
  if (debug_level_d >= Integral::ALL) {
    cepstrum_a.debug(L"cepstrum");
  }
  
  // exit gracefully
  //
  return true;
}

// method: computeIdctT4Float
//
// arguments:
//  VectorFloat& cepstrum: (output) cepstral coefficients
//  const VectorFloat& logspectrum: (input) input log magnitude spectrum
//
// return: a boolean value indicating status
//
// this method gives the cepstral coefficients for given input log
// magnitude spectrum using computeIdct algorithm and TYPE_IV implementation
//
boolean Cepstrum::computeIdctT4Float(VectorFloat& cepstrum_a,
			     const VectorFloat& logspectrum_a) {
  
  // check the algorithm and implementation
  //
  if ((algorithm_d = IDCT) && (implementation_d != TYPE_IV)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // declare local variable
  //
  long comp_num_coeffs = order_d + (long)1;

  // compute the order
  //
  Long order;
  order.max(comp_num_coeffs, logspectrum_a.length());
  
  // setup the algorithm
  //
  if (!ft_d.setAlgorithm(FourierTransform::DCT)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // setup the implementation
  //
  if (!ft_d.setImplementation(FourierTransform::TYPE_IV)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the direction
  //
  if (!ft_d.setDirection(FourierTransform::INVERSE)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the resolution
  //
  if (!ft_d.setResolution(FourierTransform::FIXED)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the input length (order of computeIdct)
  //
  if (!ft_d.setInputLength(order)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }

  // setup the output length
  //
  if (!ft_d.setOutputLength(comp_num_coeffs)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // call compute method of fourier transform
  //
  if (!ft_d.compute(cepstrum_a, logspectrum_a)) {
    return Error::handle(name(), L"computeIdctT4Float",
			 ERR, __FILE__, __LINE__);
  }
  
  // output debugging information
  //
  if (debug_level_d >= Integral::ALL) {
    cepstrum_a.debug(L"cepstrum");
  }
  
  // exit gracefully
  //
  return true;
}

// method: computeIdftConvRealFloat
//
// arguments:
//  VectorComplexFloat& cepstrum: (output) cepstral coefficients
//  const VectorFloat& logspectrum: (input) input log magnitude spectrum
//
// return: a boolean value indicating status
//
// this method implements a DFT-based computation on floats.
//
boolean Cepstrum::computeIdftConvRealFloat(VectorComplexFloat& cepstrum_a,
					   const VectorFloat& logspectrum_a) {
  
  // check the algorithm and implementation
  //
  if ((algorithm_d != IDFT) && (implementation_d != CONVENTIONAL)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }

  // declare local variable
  //
  long comp_num_coeffs = order_d + (long)1;

  // compute the order
  //
  Long order;
  order.max(comp_num_coeffs, logspectrum_a.length());
  
  // setup the algorithm
  //
  if (!ft_d.setAlgorithm(FourierTransform::DFT)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }
  
  // setup the implementation
  //
  if (!ft_d.setImplementation(FourierTransform::CONVENTIONAL)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }

  // setup the direction
  //
  if (!ft_d.setDirection(FourierTransform::INVERSE)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }

  // setup the resolution
  //
  if (!ft_d.setResolution(FourierTransform::AUTO)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }

  // setup the input length (order of computeIdft)
  //
  if (!ft_d.setInputLength(order)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }

  // setup the output length
  //
  if (!ft_d.setOutputLength(comp_num_coeffs)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }
  
  // call compute method of fourier transform
  //
  if (!ft_d.compute(cepstrum_a, logspectrum_a)) {
    return Error::handle(name(), L"computeIdftConvRealFloat",
			 ERR, __FILE__, __LINE__);
  }

  // output debugging information
  //
  if (debug_level_d >= Integral::ALL) {
    cepstrum_a.debug(L"cepstrum");
  }
  
  // exit gracefully
  //
  return true;
}

// method: computeIdftConvComplexFloat
//
// arguments:
//  VectorComplexFloat& cepstrum: (output) cepstral coefficients
//  const VectorComplexFloat& logspectrum: (input) input log spectrum
//
// return: a boolean value indicating status
//
// this method implements a DFT-based computation on complex floats.
//
boolean Cepstrum::computeIdftConvComplexFloat(VectorComplexFloat& cepstrum_a,
						 const VectorComplexFloat&
						 logspectrum_a) {
  
  // check the algorithm and implementation
  //
  if ((algorithm_d != IDFT) && (implementation_d != CONVENTIONAL)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }

  // declare local variable
  //
  long comp_num_coeffs = order_d + (long)1;

  // compute the order
  //
  Long order;
  order.max(comp_num_coeffs, logspectrum_a.length());
  
  // setup the algorithm
  //
  if (!ft_d.setAlgorithm(FourierTransform::DFT)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }
  
  // setup the implementation
  //
  if (!ft_d.setImplementation(FourierTransform::CONVENTIONAL)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }

  // setup the direction
  //
  if (!ft_d.setDirection(FourierTransform::INVERSE)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }

  // setup the resolution
  //
  if (!ft_d.setResolution(FourierTransform::AUTO)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }

  // setup the input length (order of computeIdft)
  //
  if (!ft_d.setInputLength(order)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }
  
  // setup the output length
  //
  if (!ft_d.setOutputLength(comp_num_coeffs)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }
  
  // call compute method of fourier transform
  //
  if (!ft_d.compute(cepstrum_a, logspectrum_a)) {
    return Error::handle(name(), L"computeIdftConvComplexFloat",
			 ERR, __FILE__, __LINE__);
  }
  
  // output debugging information
  //
  if (debug_level_d >= Integral::ALL) {
    cepstrum_a.debug(L"cepstrum");
  }
  
  // exit gracefully
  //
  return true;
}