#include <feature-mfcc.h>

Collaboration diagram for MfccComputer:

[legend]

Public Types
typedef MfccOptions	Options

Public Member Functions
	MfccComputer (const MfccOptions &opts)

	MfccComputer (const MfccComputer &other)

const FrameExtractionOptions &	GetFrameOptions () const

int32	Dim () const

bool	NeedRawLogEnergy () const

void	Compute (BaseFloat signal_raw_log_energy, BaseFloat vtln_warp, VectorBase< BaseFloat > signal_frame, VectorBase< BaseFloat > feature)
	Function that computes one frame of features from one frame of signal. More...

	~MfccComputer ()

Protected Member Functions
const MelBanks *	GetMelBanks (BaseFloat vtln_warp)

Protected Attributes
MfccOptions	opts_

Vector< BaseFloat >	lifter_coeffs_

Matrix< BaseFloat >	dct_matrix_

BaseFloat	log_energy_floor_

std::map< BaseFloat, MelBanks * >	mel_banks_

SplitRadixRealFft< BaseFloat > *	srfft_

Vector< BaseFloat >	mel_energies_

Private Member Functions
MfccComputer &	operator= (const MfccComputer &in)

Detailed Description

Definition at line 87 of file feature-mfcc.h.

Member Typedef Documentation

◆ Options

typedef MfccOptions Options

Definition at line 89 of file feature-mfcc.h.

Constructor & Destructor Documentation

◆ MfccComputer() [1/2]

MfccComputer ( const MfccOptions & opts )

explicit

Definition at line 82 of file feature-mfcc.cc.

References MfccOptions::cepstral_lifter, kaldi::ComputeDctMatrix(), kaldi::ComputeLifterCoeffs(), MatrixBase< Real >::CopyFromMat(), MfccComputer::dct_matrix_, MfccOptions::energy_floor, MfccOptions::frame_opts, MfccComputer::GetMelBanks(), KALDI_ERR, MfccComputer::lifter_coeffs_, kaldi::Log(), MfccComputer::log_energy_floor_, MfccOptions::mel_opts, MelBanksOptions::num_bins, MfccOptions::num_ceps, FrameExtractionOptions::PaddedWindowSize(), Matrix< Real >::Resize(), and MfccComputer::srfft_.

                                                  :
     opts_(opts), srfft_(NULL),
     mel_energies_(opts.mel_opts.num_bins) {
 
   int32 num_bins = opts.mel_opts.num_bins;
   if (opts.num_ceps > num_bins)
     KALDI_ERR << "num-ceps cannot be larger than num-mel-bins."
               << " It should be smaller or equal. You provided num-ceps: "
               << opts.num_ceps << "  and num-mel-bins: "
               << num_bins;
 
   Matrix<BaseFloat> dct_matrix(num_bins, num_bins);
   ComputeDctMatrix(&dct_matrix);
   // Note that we include zeroth dct in either case.  If using the
   // energy we replace this with the energy.  This means a different
   // ordering of features than HTK.
   SubMatrix<BaseFloat> dct_rows(dct_matrix, 0, opts.num_ceps, 0, num_bins);
   dct_matrix_.Resize(opts.num_ceps, num_bins);
   dct_matrix_.CopyFromMat(dct_rows);  // subset of rows.
   if (opts.cepstral_lifter != 0.0) {
     lifter_coeffs_.Resize(opts.num_ceps);
     ComputeLifterCoeffs(opts.cepstral_lifter, &lifter_coeffs_);
   }
   if (opts.energy_floor > 0.0)
     log_energy_floor_ = Log(opts.energy_floor);
 
   int32 padded_window_size = opts.frame_opts.PaddedWindowSize();
   if ((padded_window_size & (padded_window_size-1)) == 0)  // Is a power of two...
     srfft_ = new SplitRadixRealFft<BaseFloat>(padded_window_size);
 
   // We'll definitely need the filterbanks info for VTLN warping factor 1.0.
   // [note: this call caches it.]
   GetMelBanks(1.0);
 }

◆ MfccComputer() [2/2]

MfccComputer ( const MfccComputer & other )

Definition at line 117 of file feature-mfcc.cc.

References MfccComputer::mel_banks_, and MfccComputer::srfft_.

                                                    :
     opts_(other.opts_), lifter_coeffs_(other.lifter_coeffs_),
     dct_matrix_(other.dct_matrix_),
     log_energy_floor_(other.log_energy_floor_),
     mel_banks_(other.mel_banks_),
     srfft_(NULL),
     mel_energies_(other.mel_energies_.Dim(), kUndefined) {
   for (std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.begin();
        iter != mel_banks_.end(); ++iter)
     iter->second = new MelBanks(*(iter->second));
   if (other.srfft_ != NULL)
     srfft_ = new SplitRadixRealFft<BaseFloat>(*(other.srfft_));
 }

◆ ~MfccComputer()

~MfccComputer ( )

Definition at line 133 of file feature-mfcc.cc.

References MfccComputer::mel_banks_, and MfccComputer::srfft_.

                             {
   for (std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.begin();
       iter != mel_banks_.end();
       ++iter)
     delete iter->second;
   delete srfft_;
 }

Member Function Documentation

◆ Compute()

void Compute	(	BaseFloat	signal_raw_log_energy,
		BaseFloat	vtln_warp,
		VectorBase< BaseFloat > *	signal_frame,
		VectorBase< BaseFloat > *	feature
	)

Function that computes one frame of features from one frame of signal.

Parameters

[in]	signal_raw_log_energy	The log-energy of the frame of the signal prior to windowing and pre-emphasis, or log(numeric_limits<float>::min()), whichever is greater. Must be ignored by this function if this class returns false from this->NeedsRawLogEnergy().
[in]	vtln_warp	The VTLN warping factor that the user wants to be applied when computing features for this utterance. Will normally be 1.0, meaning no warping is to be done. The value will be ignored for feature types that don't support VLTN, such as spectrogram features.
[in]	signal_frame	One frame of the signal, as extracted using the function ExtractWindow() using the options returned by this->GetFrameOptions(). The function will use the vector as a workspace, which is why it's a non-const pointer.
[out]	feature	Pointer to a vector of size this->Dim(), to which the computed feature will be written.

Definition at line 28 of file feature-mfcc.cc.

References VectorBase< Real >::AddMatVec(), MfccOptions::cepstral_lifter, kaldi::ComputePowerSpectrum(), VectorBase< Real >::Data(), MfccComputer::dct_matrix_, VectorBase< Real >::Dim(), MfccComputer::Dim(), MfccOptions::energy_floor, MfccOptions::frame_opts, MfccComputer::GetMelBanks(), MfccOptions::htk_compat, rnnlm::i, KALDI_ASSERT, kaldi::kNoTrans, MfccComputer::lifter_coeffs_, kaldi::Log(), MfccComputer::log_energy_floor_, M_SQRT2, MfccComputer::mel_energies_, VectorBase< Real >::MulElements(), MfccOptions::num_ceps, MfccComputer::opts_, FrameExtractionOptions::PaddedWindowSize(), MfccOptions::raw_energy, kaldi::RealFft(), VectorBase< Real >::SetZero(), MfccComputer::srfft_, MfccOptions::use_energy, and kaldi::VecVec().

                                                            {
   KALDI_ASSERT(signal_frame->Dim() == opts_.frame_opts.PaddedWindowSize() &&
                feature->Dim() == this->Dim());
 
   const MelBanks &mel_banks = *(GetMelBanks(vtln_warp));
 
   if (opts_.use_energy && !opts_.raw_energy)
     signal_raw_log_energy = Log(std::max<BaseFloat>(VecVec(*signal_frame, *signal_frame),
                                      std::numeric_limits<float>::epsilon()));
 
   if (srfft_ != NULL)  // Compute FFT using the split-radix algorithm.
     srfft_->Compute(signal_frame->Data(), true);
   else  // An alternative algorithm that works for non-powers-of-two.
     RealFft(signal_frame, true);
 
   // Convert the FFT into a power spectrum.
   ComputePowerSpectrum(signal_frame);
   SubVector<BaseFloat> power_spectrum(*signal_frame, 0,
                                       signal_frame->Dim() / 2 + 1);
 
   mel_banks.Compute(power_spectrum, &mel_energies_);
 
   // avoid log of zero (which should be prevented anyway by dithering).
   mel_energies_.ApplyFloor(std::numeric_limits<float>::epsilon());
   mel_energies_.ApplyLog();  // take the log.
 
   feature->SetZero();  // in case there were NaNs.
   // feature = dct_matrix_ * mel_energies [which now have log]
   feature->AddMatVec(1.0, dct_matrix_, kNoTrans, mel_energies_, 0.0);
 
   if (opts_.cepstral_lifter != 0.0)
     feature->MulElements(lifter_coeffs_);
 
   if (opts_.use_energy) {
     if (opts_.energy_floor > 0.0 && signal_raw_log_energy < log_energy_floor_)
       signal_raw_log_energy = log_energy_floor_;
     (*feature)(0) = signal_raw_log_energy;
   }
 
   if (opts_.htk_compat) {
     BaseFloat energy = (*feature)(0);
     for (int32 i = 0; i < opts_.num_ceps - 1; i++)
       (*feature)(i) = (*feature)(i+1);
     if (!opts_.use_energy)
       energy *= M_SQRT2;  // scale on C0 (actually removing a scale
     // we previously added that's part of one common definition of
     // the cosine transform.)
     (*feature)(opts_.num_ceps - 1)  = energy;
   }
 }

◆ Dim()

int32 Dim ( ) const

inline

Definition at line 97 of file feature-mfcc.h.

Referenced by MfccComputer::Compute().

97 { return opts_.num_ceps; }

kaldi::MfccOptions::num_ceps

int32 num_ceps

Definition: feature-mfcc.h:41

kaldi::MfccComputer::opts_

MfccOptions opts_

Definition: feature-mfcc.h:135

◆ GetFrameOptions()

const FrameExtractionOptions& GetFrameOptions ( ) const

inline

Definition at line 93 of file feature-mfcc.h.

                                                         {
     return opts_.frame_opts;
   }

◆ GetMelBanks()

const MelBanks * GetMelBanks ( BaseFloat vtln_warp )

protected

Definition at line 141 of file feature-mfcc.cc.

References MfccOptions::frame_opts, MfccComputer::mel_banks_, MfccOptions::mel_opts, and MfccComputer::opts_.

Referenced by MfccComputer::Compute(), and MfccComputer::MfccComputer().

                                                              {
   MelBanks *this_mel_banks = NULL;
   std::map<BaseFloat, MelBanks*>::iterator iter = mel_banks_.find(vtln_warp);
   if (iter == mel_banks_.end()) {
     this_mel_banks = new MelBanks(opts_.mel_opts,
                                   opts_.frame_opts,
                                   vtln_warp);
     mel_banks_[vtln_warp] = this_mel_banks;
   } else {
     this_mel_banks = iter->second;
   }
   return this_mel_banks;
 }