ft_16.cc

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

// file: $isip/class/algo/FourierTransform/ft_16.cc
// version: $Id: ft_16.cc,v 1.5 2002/05/31 21:57:29 picone Exp $
//

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

// method: dct2Init
//
// arguments:
//  long order: (input) new order
//
// return: a boolean value indicating status
//
// this method creates lookup tables for the discrete cosine transform
//
boolean FourierTransform::dct2Init(long order_a) {

  return Error::handle(name(), L"dct2Init", ERR, __FILE__, __LINE__);
}

// method: dct2Real
//
// arguments:
//  VectorFloat& output: (output) output data vector
//  const VectorFloat& input: (input) input data vector
//
// return: a boolean value indicating status
//
// this method implements a discrete cosine transformation with type 2
// (DCT_II) given input vector
//
// this code very closely follows the algorithm described in:
//   X. Huang, A. Acero, and H. Hon, Spoken Language Processing,
//   Prentice Hall PTR, Upper Saddle River, New Jersey, pp. 228, 2001.
//   
//   K, Rao, and P. Yip, Discrete Cosine Transform: Algorithms,
//   Advantages and Applications, Academic Press, San Diego,
//   California, pp. 15, 1990.
//
// Forward Algorithm:
//  C[k] = sqrt(2/N) * c[k] * sum{x[n] * cos(k*(2n+1)*pi/2N)}, k = 0,1,..,N-1
//                         n=[0:N-1]
//
// Inverse Algorithm:
//  x[n] = sqrt(2/N) * sum{c[k] * C[k] * cos(k*(2n+1)*pi/2N)}, n = 0,1,..,N-1
//                  k=[0:N-1]
//
//    where, c[k] = 1 / sqrt(2) when k = 0 or N
//           c[k] = 1           when k != 0 or N
//
boolean FourierTransform::dct2Real(VectorFloat& output_a,
				   const VectorFloat& input_a) {

  // declare local variable
  //  N: required input length
  //  M: default or user specified output length
  //
  long N = input_a.length();
  long M = (olen_d == DEF_LENGTH) ? N : (long)olen_d;
  float norm_factor = sqrt(2.0 / N);
  float norm_N = sqrt(0.5);
  float sum;
  
  // set the length of the output vector
  //
  output_a.setLength(M);

  // compute discrete cosine transform
  //
  if (direction_d == FORWARD) {

    // forward algorithm of DCT_II
    //
    for (long k = 0; k < M; k++) {
      
      // initialize values to zero
      //
      sum = 0.0;
      
      // loop over the length of input vector
      //
      for (long n = 0; n < N; n++) {
	sum += (float)input_a(n) *
	  cos(k * (2 * n + 1) * (Integral::PI) / (2 * N));
      }

      // normalize the output coefficients
      //
      if (k % N) {
	output_a(k) = sum * norm_factor;
      }
      else {
	output_a(k) = sum * norm_factor * norm_N;
      }
    }
  }

  else {

    // inverse algorithm of DCT_II
    //
    for (long n = 0; n < M; n++) {
      
      // initialize output value
      //
      sum = input_a(0) * norm_N;
      
      // loop over the length of input vector
      //
      for (long k = 1; k < N; k++) {
	sum += (float)input_a(k) *
	  cos(k * (2 * n + 1) * (Integral::PI) / (2 * N));
      }
      output_a(n) = sum * norm_factor;
    }
  }    

  // exit gracefully
  //
  return true;
}

// method: dct2Complex
//
// arguments:
//  VectorFloat& output: (output) output data vector
//  const VectorFloat& input: (input) input data vector
//
// return: a boolean value indicating status
//
// this method computes the discrete cosine transform of given input vector
//
boolean FourierTransform::dct2Complex(VectorFloat& output_a,
				     const VectorFloat& input_a) {

  return Error::handle(name(), L"dct2Complex", Error::NOT_IMPLEM,
		       __FILE__, __LINE__);  
  
}