cepstrum.h

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

// file: $isip/class/algo/Cepstrum/Cepstrum.h
// version: $Id: Cepstrum.h,v 1.40 2002/11/26 20:16:04 parihar Exp $
//

// make sure definitions are only made once
//
#ifndef ISIP_CEPSTRUM
#define ISIP_CEPSTRUM

// isip include files
//
#ifndef ISIP_ALGORITHM_BASE
#include <AlgorithmBase.h>
#endif

// isip include files
//
#ifndef ISIP_FOURIER_TRANSFORM
#include <FourierTransform.h>
#endif

// isip include files
//
#ifndef ISIP_BOOLEAN
#include <Boolean.h>
#endif

// Cepstrum: a class that computes cepstral coefficients. it is a
// homomorphic space which allows the deconvolution of the signal from
// vocal tract shape. liftering can be accomplished to smooth
// non-information bearing variability, by means of Window class using
// LIFTER algorithm.
//
class Cepstrum : public AlgorithmBase {

  //---------------------------------------------------------------------------
  //
  // public constants
  //
  //---------------------------------------------------------------------------
public:
  
  // define the class name
  //
  static const String CLASS_NAME;

  //----------------------------------------
  //
  // other important constants
  //
  //----------------------------------------
    
  // define algorithm types
  //
  enum ALGORITHM { IDCT = 0, IDFT, DEF_ALGORITHM = IDCT };

  // define implementation choices
  //
  enum IMPLEMENTATION { TYPE_I = 0, TYPE_II, TYPE_III, TYPE_IV,
			CONVENTIONAL,
			DEF_IMPLEMENTATION = TYPE_III };
  
  // define static NameMap objects
  //
  static const NameMap ALGO_MAP;
  static const NameMap IMPL_MAP;

  //----------------------------------------
  //
  // i/o related constants
  //
  //----------------------------------------  

  static const String DEF_PARAM;
  static const String PARAM_ORDER;
  static const String PARAM_ALGORITHM;
  static const String PARAM_IMPLEMENTATION;
  static const String PARAM_MIN_AMP;
  static const String PARAM_FLAG_MIN_AMP;
  
  //----------------------------------------
  //
  // default values and arguments
  //
  //----------------------------------------  

  // define the default value(s) of the class data
  //  
  static const long DEF_ORDER = 12;
  static const float DEF_MIN_AMP = Integral::MIN_LOG_VALUE;
  static const boolean DEF_FLAG_MIN_AMP = false;

  // define default argument(s)
  //
  static const AlgorithmData::COEF_TYPE DEF_COEF_TYPE =
  AlgorithmData::SPECTRUM;
  
  //----------------------------------------
  //
  // error codes
  //
  //----------------------------------------  
  
  static const long ERR = 70300;
  
  //---------------------------------------------------------------------------
  //
  // protected data
  //
  //---------------------------------------------------------------------------
protected:
  
  // algorithm name
  //
  ALGORITHM algorithm_d;

  // implementation name
  //
  IMPLEMENTATION implementation_d;
  
  // declare the FourierTransform object
  //
  FourierTransform ft_d;

  // number of cepstral coefficients
  //
  Long order_d;

  // minimum input amplitude allowed for input
  //
  Float min_amp_d;

  // a flag that denotes that minimum input amplitude is to be
  // enforced
  //
  Boolean flag_min_amp_d;

  // memory manager
  //
  static MemoryManager mgr_d;
  
  //---------------------------------------------------------------------------
  //
  // required public methods
  //
  //---------------------------------------------------------------------------
public:
    
  // method: name
  //
  static const String& name() {
    return CLASS_NAME;
  }

  // other static methods
  //
  static boolean diagnose(Integral::DEBUG debug_level);
  
  // debug methods:
  //  setDebug method is inherited from the base class
  //
  boolean debug(const unichar* msg) const;

  // method: destructor
  //
  ~Cepstrum() {}

  // default constructor
  //
  Cepstrum(ALGORITHM algorithm = DEF_ALGORITHM,
	   IMPLEMENTATION implementation = DEF_IMPLEMENTATION,
	   long order = DEF_ORDER, float min_amp = DEF_MIN_AMP,
	   boolean flag_min_amp = DEF_FLAG_MIN_AMP) {
    algorithm_d = algorithm;
    implementation_d = implementation;
    order_d = order;
    min_amp_d = min_amp;
    flag_min_amp_d = flag_min_amp;
    is_valid_d = false;
  }

  // method: copy constructor
  //  
  Cepstrum(const Cepstrum& arg) {
    assign(arg);
  }

  // assign methods
  //
  boolean assign(const Cepstrum& arg);
  
  // method: operator=
  //
  Cepstrum& operator= (const Cepstrum& copy_node) {
    assign(copy_node);
    return *this;
  }
  
  // i/o methods
  //
  long sofSize() const;
  
  boolean read(Sof& sof, long tag, const String& name = CLASS_NAME);
  boolean write(Sof& sof, long tag, const String& name = CLASS_NAME) const;

  boolean readData(Sof& sof, const String& pname = DEF_PARAM,
		   long size = SofParser::FULL_OBJECT,
		   boolean param = true,
                   boolean nested = false);
  boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;
  
  // method: eq
  //
  boolean eq(const Cepstrum& arg) const;
  
  // method: new
  //
  static void* operator new(size_t size) {
    return mgr_d.get();
  }

  // method: new[]
  //
  static void* operator new[](size_t size) {
    return mgr_d.getBlock(size);
  }

  // method: delete
  //
  static void operator delete(void* ptr) {
    mgr_d.release(ptr);
  }
  
  // method: delete[]
  //
  static void operator delete[](void* ptr) {
    mgr_d.releaseBlock(ptr);
  }
  
  // method: setGrowSize
  //
  static boolean setGrowSize(long grow_size) {
    return mgr_d.setGrow(grow_size);
  }

  // other memory management methods
  //  
  boolean clear(Integral::CMODE ctype = Integral::DEF_CMODE);
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  set methods
  //
  //---------------------------------------------------------------------------

  // method: setAlgorithm
  //
  boolean setAlgorithm(ALGORITHM algorithm) {
    algorithm_d = algorithm;
    is_valid_d = false;
    return true;  
  }

  // method: setImplementation
  //
  boolean setImplementation(IMPLEMENTATION implementation) {
    implementation_d = implementation;
    is_valid_d = false;
    return true;  
  }  
  
  // method: setOrder
  //
  boolean setOrder(long num) {
    order_d = num;
    is_valid_d = false;
    return true;
  }

  // method: setMinimumAmplitude
  //
  boolean setMinimumAmplitude(float min_amp) {
    min_amp_d = min_amp;
    flag_min_amp_d = true;
    is_valid_d = false;
    return true;
  }

  // method: setFlagMinimumAmplitude
  //
  boolean setFlagMinimumAmplitude(boolean flag_min_amp) {
    flag_min_amp_d = flag_min_amp;
    is_valid_d = false;
    return true;
  }

  // method: set
  //
  boolean set(ALGORITHM algorithm = DEF_ALGORITHM,
	      IMPLEMENTATION implementation = DEF_IMPLEMENTATION,
	      long order = DEF_ORDER, float min_amp = DEF_MIN_AMP,
	      boolean flag_min_amp = DEF_FLAG_MIN_AMP) {
    algorithm_d = algorithm;
    implementation_d = implementation;
    order_d = order;
    min_amp_d = min_amp;
    flag_min_amp_d = flag_min_amp;
    is_valid_d = false;
    return true;
  }

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  get methods
  //
  //---------------------------------------------------------------------------

  // method: getAlgorithm
  //
  ALGORITHM getAlgorithm() const {  
    return algorithm_d;
  }

  // method: getImplementation
  //
  IMPLEMENTATION getImplementation() const {
    return implementation_d;
  }
  
  // method: getOrder
  //
  long getOrder() const {
    return order_d;
  }

  // method: getMinimumAmplitude
  //
  float getMinimumAmplitude() const {
    return min_amp_d;
  }

  // method: getFlagMinimumAmplitude
  //
  boolean getFlagMinimumAmplitude() const {
    return flag_min_amp_d;
  }

  // method: get
  //
  boolean get(ALGORITHM& algorithm,
	      IMPLEMENTATION& implementation,
	      long& order, float& min_amp, boolean& flag_min_amp) {
    algorithm = algorithm_d;
    implementation = implementation_d;
    order = order_d;
    min_amp = min_amp_d;
    flag_min_amp = flag_min_amp_d;
    return true;
  }

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  computational methods
  //
  //---------------------------------------------------------------------------

  boolean compute(VectorFloat& output, const VectorFloat& input,
		  AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE,
		  long index = DEF_CHANNEL_INDEX);
  boolean compute(VectorComplexFloat& output, const VectorComplexFloat& input,
		  AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE,
		  long index = DEF_CHANNEL_INDEX);
  boolean compute(VectorFloat& output, const VectorComplexFloat& input,
		  AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE,
		  long index = DEF_CHANNEL_INDEX);
  boolean compute(VectorComplexFloat& output, const VectorFloat& input,
		  AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE,
		  long index = DEF_CHANNEL_INDEX);

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:  
  //  AlgorithmBase interface contract methods
  //
  //---------------------------------------------------------------------------

  // assign method
  //
  boolean assign(const AlgorithmBase& arg);

  // equality method
  //  
  boolean eq(const AlgorithmBase& arg) const;
  
  // method: className
  //
  const String& className() const {
    return CLASS_NAME;
  }
  
  // apply method
  //
  boolean apply(Vector<AlgorithmData>& output,
		const Vector< CircularBuffer<AlgorithmData> >& input);

  // parser methods
  //
  boolean setParser(SofParser* parser);
  
  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:
  
  // algorithm-specific i/o methods
  //
  boolean readDataCommon(Sof& sof, const String& pname,
                         long size = SofParser::FULL_OBJECT,
                         boolean param = true, boolean nested = false);
  boolean writeDataCommon(Sof& sof, const String& pname) const;
  
  // algorithm and implementation specific computational methods
  //
  boolean computeIdctT1Float(VectorFloat& cepstrum,
			     const VectorFloat& spectrum);
  boolean computeIdctT2Float(VectorFloat& cepstrum,
			     const VectorFloat& spectrum);
  boolean computeIdctT3Float(VectorFloat& cepstrum,
			     const VectorFloat& spectrum);
  boolean computeIdctT4Float(VectorFloat& cepstrum,
			     const VectorFloat& spectrum);
  boolean computeIdftConvRealFloat(VectorComplexFloat& cepstrum,
				   const VectorFloat& spectrum);
  boolean computeIdftConvComplexFloat(VectorComplexFloat& cepstrum,
				      const VectorComplexFloat& spectrum);
};

// end of include file
// 
#endif