LinearResample Class Reference

LinearResample is a special case of ArbitraryResample, where we want to resample a signal at linearly spaced intervals (this means we want to upsample or downsample the signal). More...

#include <resample.h>

Collaboration diagram for LinearResample:

Public Member Functions
	LinearResample (int32 samp_rate_in_hz, int32 samp_rate_out_hz, BaseFloat filter_cutoff_hz, int32 num_zeros)
	Constructor. More...
void	Resample (const VectorBase< BaseFloat > &input, bool flush, Vector< BaseFloat > *output)
	This function does the resampling. More...
void	Reset ()
	Calling the function Reset() resets the state of the object prior to processing a new signal; it is only necessary if you have called Resample(x, y, false) for some signal, leading to a remainder of the signal being called, but then abandon processing the signal before calling Resample(x, y, true) for the last piece. More...
int32	GetInputSamplingRate ()
int32	GetOutputSamplingRate ()

Private Member Functions
int64	GetNumOutputSamples (int64 input_num_samp, bool flush) const
	This function outputs the number of output samples we will output for a signal with "input_num_samp" input samples. More...
void	GetIndexes (int64 samp_out, int64 *first_samp_in, int32 *samp_out_wrapped) const
	Given an output-sample index, this function outputs to *first_samp_in the first input-sample index that we have a weight on (may be negative), and to *samp_out_wrapped the index into weights_ where we can get the corresponding weights on the input. More...
void	SetRemainder (const VectorBase< BaseFloat > &input)
void	SetIndexesAndWeights ()
BaseFloat	FilterFunc (BaseFloat) const
	Here, t is a time in seconds representing an offset from the center of the windowed filter function, and FilterFunction(t) returns the windowed filter function, described in the header as h(t) = f(t)g(t), evaluated at t. More...

Private Attributes
int32	samp_rate_in_
int32	samp_rate_out_
BaseFloat	filter_cutoff_
int32	num_zeros_
int32	input_samples_in_unit_
	The number of input samples in the smallest repeating unit: num_samp_in_ = samp_rate_in_hz / Gcd(samp_rate_in_hz, samp_rate_out_hz) More...
int32	output_samples_in_unit_
	The number of output samples in the smallest repeating unit: num_samp_out_ = samp_rate_out_hz / Gcd(samp_rate_in_hz, samp_rate_out_hz) More...
std::vector< int32 >	first_index_
	The first input-sample index that we sum over, for this output-sample index. More...
std::vector< Vector< BaseFloat > >	weights_
	Weights on the input samples, for this output-sample index. More...
int64	input_sample_offset_
	The number of input samples we have already received for this signal (including anything in remainder_) More...
int64	output_sample_offset_
	The number of samples we have already output for this signal. More...
Vector< BaseFloat >	input_remainder_
	A small trailing part of the previously seen input signal. More...

Detailed Description

LinearResample is a special case of ArbitraryResample, where we want to resample a signal at linearly spaced intervals (this means we want to upsample or downsample the signal).

It is more efficient than ArbitraryResample because we can construct it just once.

We require that the input and output sampling rate be specified as integers, as this is an easy way to specify that their ratio be rational.

Definition at line 147 of file resample.h.

Constructor & Destructor Documentation

LinearResample()

LinearResample	(	int32	samp_rate_in_hz,
		int32	samp_rate_out_hz,
		BaseFloat	filter_cutoff_hz,
		int32	num_zeros
	)

Constructor.

We make the input and output sample rates integers, because we are going to need to find a common divisor. This should just remind you that they need to be integers. The filter cutoff needs to be less than samp_rate_in_hz/2 and less than samp_rate_out_hz/2. num_zeros controls the sharpness of the filter, more == sharper but less efficient. We suggest around 4 to 10 for normal use.

Definition at line 33 of file resample.cc.

References kaldi::Gcd(), LinearResample::input_samples_in_unit_, KALDI_ASSERT, LinearResample::output_samples_in_unit_, LinearResample::Reset(), LinearResample::samp_rate_in_, LinearResample::samp_rate_out_, and LinearResample::SetIndexesAndWeights().

                                               :
    samp_rate_in_(samp_rate_in_hz),
    samp_rate_out_(samp_rate_out_hz),
    filter_cutoff_(filter_cutoff_hz),
    num_zeros_(num_zeros) {
  KALDI_ASSERT(samp_rate_in_hz > 0.0 &&
               samp_rate_out_hz > 0.0 &&
               filter_cutoff_hz > 0.0 &&
               filter_cutoff_hz*2 <= samp_rate_in_hz &&
               filter_cutoff_hz*2 <= samp_rate_out_hz &&
               num_zeros > 0);

  // base_freq is the frequency of the repeating unit, which is the gcd
  // of the input frequencies.
  int32 base_freq = Gcd(samp_rate_in_, samp_rate_out_);
  input_samples_in_unit_ = samp_rate_in_ / base_freq;
  output_samples_in_unit_ = samp_rate_out_ / base_freq;

  SetIndexesAndWeights();
  Reset();
}

Member Function Documentation

FilterFunc()

BaseFloat FilterFunc ( BaseFloat  t ) const

private

Here, t is a time in seconds representing an offset from the center of the windowed filter function, and FilterFunction(t) returns the windowed filter function, described in the header as h(t) = f(t)g(t), evaluated at t.

Definition at line 246 of file resample.cc.

References LinearResample::filter_cutoff_, M_2PI, M_PI, and LinearResample::num_zeros_.

Referenced by LinearResample::SetIndexesAndWeights().

                                                      {
  BaseFloat window,  // raised-cosine (Hanning) window of width
                  // num_zeros_/2*filter_cutoff_
      filter;  // sinc filter function
  if (fabs(t) < num_zeros_ / (2.0 * filter_cutoff_))
    window = 0.5 * (1 + cos(M_2PI * filter_cutoff_ / num_zeros_ * t));
  else
    window = 0.0;  // outside support of window function
  if (t != 0)
    filter = sin(M_2PI * filter_cutoff_ * t) / (M_PI * t);
  else
    filter = 2 * filter_cutoff_;  // limit of the function at t = 0
  return filter * window;
}

GetIndexes()

void GetIndexes ( int64  samp_out, int64 *  first_samp_in, int32 *  samp_out_wrapped  ) const

inlineprivate

Given an output-sample index, this function outputs to *first_samp_in the first input-sample index that we have a weight on (may be negative), and to *samp_out_wrapped the index into weights_ where we can get the corresponding weights on the input.

Definition at line 137 of file resample.cc.

References LinearResample::first_index_, LinearResample::input_samples_in_unit_, and LinearResample::output_samples_in_unit_.

Referenced by LinearResample::Resample().

                                                               {
  // A unit is the smallest nonzero amount of time that is an exact
  // multiple of the input and output sample periods.  The unit index
  // is the answer to "which numbered unit we are in".
  int64 unit_index = samp_out / output_samples_in_unit_;
  // samp_out_wrapped is equal to samp_out % output_samples_in_unit_
  *samp_out_wrapped = static_cast<int32>(samp_out -
                                         unit_index * output_samples_in_unit_);
  *first_samp_in = first_index_[*samp_out_wrapped] +
      unit_index * input_samples_in_unit_;
}

GetInputSamplingRate()

int32 GetInputSamplingRate ( )

inline

Definition at line 190 of file resample.h.

References ArbitraryResample::samp_rate_in_.

{ return samp_rate_in_; }

GetNumOutputSamples()

int64 GetNumOutputSamples ( int64  input_num_samp, bool  flush  ) const

private

This function outputs the number of output samples we will output for a signal with "input_num_samp" input samples.

If flush == true, we return the largest n such that (n/samp_rate_out_) is in the interval [ 0, input_num_samp/samp_rate_in_ ), and note that the interval is half-open. If flush == false, define window_width as num_zeros / (2.0 * filter_cutoff_); we return the largest n such that (n/samp_rate_out_) is in the interval [ 0, input_num_samp/samp_rate_in_ - window_width ).

Definition at line 58 of file resample.cc.

References LinearResample::filter_cutoff_, kaldi::Lcm(), LinearResample::num_zeros_, LinearResample::samp_rate_in_, and LinearResample::samp_rate_out_.

Referenced by LinearResample::Resample().

                                                            {
  // For exact computation, we measure time in "ticks" of 1.0 / tick_freq,
  // where tick_freq is the least common multiple of samp_rate_in_ and
  // samp_rate_out_.
  int32 tick_freq = Lcm(samp_rate_in_, samp_rate_out_);
  int32 ticks_per_input_period = tick_freq / samp_rate_in_;

  // work out the number of ticks in the time interval
  // [ 0, input_num_samp/samp_rate_in_ ).
  int64 interval_length_in_ticks = input_num_samp * ticks_per_input_period;
  if (!flush) {
    BaseFloat window_width = num_zeros_ / (2.0 * filter_cutoff_);
    // To count the window-width in ticks we take the floor.  This
    // is because since we're looking for the largest integer num-out-samp
    // that fits in the interval, which is open on the right, a reduction
    // in interval length of less than a tick will never make a difference.
    // For example, the largest integer in the interval [ 0, 2 ) and the
    // largest integer in the interval [ 0, 2 - 0.9 ) are the same (both one).
    // So when we're subtracting the window-width we can ignore the fractional
    // part.
    int32 window_width_ticks = floor(window_width * tick_freq);
    // The time-period of the output that we can sample gets reduced
    // by the window-width (which is actually the distance from the
    // center to the edge of the windowing function) if we're not
    // "flushing the output".
    interval_length_in_ticks -= window_width_ticks;
  }
  if (interval_length_in_ticks <= 0)
    return 0;
  int32 ticks_per_output_period = tick_freq / samp_rate_out_;
  // Get the last output-sample in the closed interval, i.e. replacing [ ) with
  // [ ].  Note: integer division rounds down.  See
  // http://en.wikipedia.org/wiki/Interval_(mathematics) for an explanation of
  // the notation.
  int64 last_output_samp = interval_length_in_ticks / ticks_per_output_period;
  // We need the last output-sample in the open interval, so if it takes us to
  // the end of the interval exactly, subtract one.
  if (last_output_samp * ticks_per_output_period == interval_length_in_ticks)
    last_output_samp--;
  // First output-sample index is zero, so the number of output samples
  // is the last output-sample plus one.
  int64 num_output_samp = last_output_samp + 1;
  return num_output_samp;
}

GetOutputSamplingRate()

int32 GetOutputSamplingRate ( )

inline

Definition at line 191 of file resample.h.

References ArbitraryResample::FilterFunc().

{ return samp_rate_out_; }

Resample()

void Resample	(	const VectorBase< BaseFloat > &	input,
		bool	flush,
		Vector< BaseFloat > *	output
	)

This function does the resampling.

If you call it with flush == true and you have never called it with flush == false, it just resamples the input signal (it resizes the output to a suitable number of samples).

You can also use this function to process a signal a piece at a time. suppose you break it into piece1, piece2, ... pieceN. You can call

Resample(piece1, &output1, false);
Resample(piece2, &output2, false);
Resample(piece3, &output3, true);

If you call it with flush == false, it won't output the last few samples but will remember them, so that if you later give it a second piece of the input signal it can process it correctly. If your most recent call to the object was with flush == false, it will have internal state; you can remove this by calling Reset(). Empty input is acceptable.

Definition at line 152 of file resample.cc.

References VectorBase< Real >::Dim(), LinearResample::GetIndexes(), LinearResample::GetNumOutputSamples(), rnnlm::i, LinearResample::input_remainder_, LinearResample::input_sample_offset_, KALDI_ASSERT, LinearResample::output_sample_offset_, LinearResample::Reset(), Vector< Real >::Resize(), LinearResample::SetRemainder(), kaldi::VecVec(), and LinearResample::weights_.

Referenced by OnlinePitchFeatureImpl::AcceptWaveform(), kaldi::ResampleWaveform(), UnitTestLinearResample(), and UnitTestLinearResample2().

                                                         {
  int32 input_dim = input.Dim();
  int64 tot_input_samp = input_sample_offset_ + input_dim,
      tot_output_samp = GetNumOutputSamples(tot_input_samp, flush);

  KALDI_ASSERT(tot_output_samp >= output_sample_offset_);

  output->Resize(tot_output_samp - output_sample_offset_);

  // samp_out is the index into the total output signal, not just the part
  // of it we are producing here.
  for (int64 samp_out = output_sample_offset_;
       samp_out < tot_output_samp;
       samp_out++) {
    int64 first_samp_in;
    int32 samp_out_wrapped;
    GetIndexes(samp_out, &first_samp_in, &samp_out_wrapped);
    const Vector<BaseFloat> &weights = weights_[samp_out_wrapped];
    // first_input_index is the first index into "input" that we have a weight
    // for.
    int32 first_input_index = static_cast<int32>(first_samp_in -
                                                 input_sample_offset_);
    BaseFloat this_output;
    if (first_input_index >= 0 &&
        first_input_index + weights.Dim() <= input_dim) {
      SubVector<BaseFloat> input_part(input, first_input_index, weights.Dim());
      this_output = VecVec(input_part, weights);
    } else {  // Handle edge cases.
      this_output = 0.0;
      for (int32 i = 0; i < weights.Dim(); i++) {
        BaseFloat weight = weights(i);
        int32 input_index = first_input_index + i;
        if (input_index < 0 && input_remainder_.Dim() + input_index >= 0) {
          this_output += weight *
              input_remainder_(input_remainder_.Dim() + input_index);
        } else if (input_index >= 0 && input_index < input_dim) {
          this_output += weight * input(input_index);
        } else if (input_index >= input_dim) {
          // We're past the end of the input and are adding zero; should only
          // happen if the user specified flush == true, or else we would not
          // be trying to output this sample.
          KALDI_ASSERT(flush);
        }
      }
    }
    int32 output_index = static_cast<int32>(samp_out - output_sample_offset_);
    (*output)(output_index) = this_output;
  }

  if (flush) {
    Reset();  // Reset the internal state.
  } else {
    SetRemainder(input);
    input_sample_offset_ = tot_input_samp;
    output_sample_offset_ = tot_output_samp;
  }
}

Reset()

void Reset

(

)

Calling the function Reset() resets the state of the object prior to processing a new signal; it is only necessary if you have called Resample(x, y, false) for some signal, leading to a remainder of the signal being called, but then abandon processing the signal before calling Resample(x, y, true) for the last piece.

Call it unnecessarily between signals will not do any harm.

Definition at line 235 of file resample.cc.

References LinearResample::input_remainder_, LinearResample::input_sample_offset_, and LinearResample::output_sample_offset_.

Referenced by LinearResample::LinearResample(), and LinearResample::Resample().

                           {
  input_sample_offset_ = 0;
  output_sample_offset_ = 0;
  input_remainder_.Resize(0);
}

SetIndexesAndWeights()

void SetIndexesAndWeights ( )

private

Definition at line 104 of file resample.cc.

References LinearResample::filter_cutoff_, LinearResample::FilterFunc(), LinearResample::first_index_, rnnlm::i, rnnlm::j, LinearResample::num_zeros_, LinearResample::output_samples_in_unit_, LinearResample::samp_rate_in_, LinearResample::samp_rate_out_, and LinearResample::weights_.

Referenced by LinearResample::LinearResample().

                                          {
  first_index_.resize(output_samples_in_unit_);
  weights_.resize(output_samples_in_unit_);

  double window_width = num_zeros_ / (2.0 * filter_cutoff_);

  for (int32 i = 0; i < output_samples_in_unit_; i++) {
    double output_t = i / static_cast<double>(samp_rate_out_);
    double min_t = output_t - window_width, max_t = output_t + window_width;
    // we do ceil on the min and floor on the max, because if we did it
    // the other way around we would unnecessarily include indexes just
    // outside the window, with zero coefficients.  It's possible
    // if the arguments to the ceil and floor expressions are integers
    // (e.g. if filter_cutoff_ has an exact ratio with the sample rates),
    // that we unnecessarily include something with a zero coefficient,
    // but this is only a slight efficiency issue.
    int32 min_input_index = ceil(min_t * samp_rate_in_),
        max_input_index = floor(max_t * samp_rate_in_),
        num_indices = max_input_index - min_input_index + 1;
    first_index_[i] = min_input_index;
    weights_[i].Resize(num_indices);
    for (int32 j = 0; j < num_indices; j++) {
      int32 input_index = min_input_index + j;
      double input_t = input_index / static_cast<double>(samp_rate_in_),
          delta_t = input_t - output_t;
      // sign of delta_t doesn't matter.
      weights_[i](j) = FilterFunc(delta_t) / samp_rate_in_;
    }
  }
}

SetRemainder()

void SetRemainder ( const VectorBase< BaseFloat > &  input )

private

Definition at line 212 of file resample.cc.

References VectorBase< Real >::Dim(), LinearResample::filter_cutoff_, LinearResample::input_remainder_, LinearResample::num_zeros_, and LinearResample::samp_rate_in_.

Referenced by LinearResample::Resample().

                                                                    {
  Vector<BaseFloat> old_remainder(input_remainder_);
  // max_remainder_needed is the width of the filter from side to side,
  // measured in input samples.  you might think it should be half that,
  // but you have to consider that you might be wanting to output samples
  // that are "in the past" relative to the beginning of the latest
  // input... anyway, storing more remainder than needed is not harmful.
  int32 max_remainder_needed = ceil(samp_rate_in_ * num_zeros_ /
                                    filter_cutoff_);
  input_remainder_.Resize(max_remainder_needed);
  for (int32 index = - input_remainder_.Dim(); index < 0; index++) {
    // we interpret "index" as an offset from the end of "input" and
    // from the end of input_remainder_.
    int32 input_index = index + input.Dim();
    if (input_index >= 0)
      input_remainder_(index + input_remainder_.Dim()) = input(input_index);
    else if (input_index + old_remainder.Dim() >= 0)
      input_remainder_(index + input_remainder_.Dim()) =
          old_remainder(input_index + old_remainder.Dim());
    // else leave it at zero.
  }
}

Member Data Documentation

filter_cutoff_

BaseFloat filter_cutoff_

private

Definition at line 221 of file resample.h.

Referenced by LinearResample::FilterFunc(), LinearResample::GetNumOutputSamples(), LinearResample::SetIndexesAndWeights(), and LinearResample::SetRemainder().

first_index_

std::vector<int32> first_index_

private

The first input-sample index that we sum over, for this output-sample index.

May be negative; any truncation at the beginning is handled separately. This is just for the first few output samples, but we can extrapolate the correct input-sample index for arbitrary output samples.

Definition at line 238 of file resample.h.

Referenced by LinearResample::GetIndexes(), and LinearResample::SetIndexesAndWeights().

input_remainder_

Vector<BaseFloat> input_remainder_

private

A small trailing part of the previously seen input signal.

Definition at line 251 of file resample.h.

Referenced by LinearResample::Resample(), LinearResample::Reset(), and LinearResample::SetRemainder().

input_sample_offset_

int64 input_sample_offset_

private

The number of input samples we have already received for this signal (including anything in remainder_)

Definition at line 246 of file resample.h.

Referenced by LinearResample::Resample(), and LinearResample::Reset().

input_samples_in_unit_

int32 input_samples_in_unit_

private

The number of input samples in the smallest repeating unit: num_samp_in_ = samp_rate_in_hz / Gcd(samp_rate_in_hz, samp_rate_out_hz)

Definition at line 224 of file resample.h.

Referenced by LinearResample::GetIndexes(), and LinearResample::LinearResample().

num_zeros_

int32 num_zeros_

private

Definition at line 222 of file resample.h.

Referenced by LinearResample::FilterFunc(), LinearResample::GetNumOutputSamples(), LinearResample::SetIndexesAndWeights(), and LinearResample::SetRemainder().

output_sample_offset_

int64 output_sample_offset_

private

The number of samples we have already output for this signal.

Definition at line 249 of file resample.h.

Referenced by LinearResample::Resample(), and LinearResample::Reset().

output_samples_in_unit_

int32 output_samples_in_unit_

private

The number of output samples in the smallest repeating unit: num_samp_out_ = samp_rate_out_hz / Gcd(samp_rate_in_hz, samp_rate_out_hz)

Definition at line 228 of file resample.h.

Referenced by LinearResample::GetIndexes(), LinearResample::LinearResample(), and LinearResample::SetIndexesAndWeights().

samp_rate_in_

int32 samp_rate_in_

private

Definition at line 219 of file resample.h.

Referenced by LinearResample::GetNumOutputSamples(), LinearResample::LinearResample(), LinearResample::SetIndexesAndWeights(), and LinearResample::SetRemainder().

samp_rate_out_

int32 samp_rate_out_

private

Definition at line 220 of file resample.h.

Referenced by LinearResample::GetNumOutputSamples(), LinearResample::LinearResample(), and LinearResample::SetIndexesAndWeights().

weights_

std::vector<Vector<BaseFloat> > weights_

private

Weights on the input samples, for this output-sample index.

Definition at line 241 of file resample.h.

Referenced by LinearResample::Resample(), and LinearResample::SetIndexesAndWeights().

---

The documentation for this class was generated from the following files:

• feat/resample.h
• feat/resample.cc