// 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