resampler.h

/*
Copyright 2018 Google Inc. All Rights Reserved.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS-IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#ifndef RESONANCE_AUDIO_DSP_RESAMPLER_H_
#define RESONANCE_AUDIO_DSP_RESAMPLER_H_
 
#include "base/audio_buffer.h"
 
namespace vraudio {
 
// Class that provides rational resampling of audio data.
class Resampler {
 public:
  Resampler();
 
  // Resamples an |AudioBuffer| of input data sampled at |source_frequency| to
  // |destination_frequency|.
  //
  // @param input Input data to be resampled.
  // @param output Resampled output data.
  void Process(const AudioBuffer& input, AudioBuffer* output);
 
  // Returns the maximum length which the output buffer will be, given the
  // current source and destination frequencies and input length. The actual
  // output length will either be this or one less.
  //
  // @param input_length Length of the input.
  // @return Maximum length of the output.
  size_t GetMaxOutputLength(size_t input_length) const;
 
  // Returns the next length which the output buffer will be, given the
  // current source and destination frequencies and input length.
  //
  // @param input_length Length of the input.
  // @return Next length of the output.
  size_t GetNextOutputLength(size_t input_length) const;
 
  // Sets the source and destination sampling rate as well as the number of
  // channels. Note this method only resets the filter state number of channel
  // changes.
  //
  // @param source_frequency Sampling rate of input data.
  // @param destination_frequency Desired output sampling rate.
  // @param num_channels Number of channels to process.
  void SetRateAndNumChannels(int source_frequency, int destination_frequency,
                             size_t num_channels);
 
  // Returns whether the sampling rates provided are supported by the resampler.
  //
  // @param source Source sampling rate.
  // @param destination Destination sampling rate.
  // @return True if the sampling rate pair are supported.
  static bool AreSampleRatesSupported(int source, int destination);
 
  // Resets the inner state of the |Resampler| allowing its use repeatedly on
  // different data streams.
  void ResetState();
 
 private:
  friend class PolyphaseFilterTest;
  // Initializes the |state_| buffer. Called when sampling rate is changed or
  // the state is reset.
  //
  // @param size_t old_state_num_frames Number of frames in the |state_| buffer
  //     previous to the most recent call to |GenerateInterpolatingFilter|.
  void InitializeStateBuffer(size_t old_state_num_frames);
 
  // Generates a windowed sinc to act as the interpolating/anti-aliasing filter.
  //
  // @param sample_rate The system sampling rate.
  void GenerateInterpolatingFilter(int sample_rate);
 
  // Arranges the anti aliasing filter coefficients in polyphase filter format.
  //
  // @param filter_length Number of frames in |filter| containing filter
  //     coefficients.
  // @param filter Vector of filter coefficients.
  void ArrangeFilterAsPolyphase(size_t filter_length,
                                const AudioBuffer::Channel& filter);
 
  // Generates Hann windowed sinc function anti aliasing filters.
  //
  // @param cutoff_frequency Transition band (-3dB) frequency of the filter.
  // @param sample_rate The system sampling rate.
  // @param filter_length Number of frames in |buffer| containing filter
  //     coefficients.
  // @param buffer |AudioBuffer::Channel| to contain the filter coefficients.
  void GenerateSincFilter(float cutoff_frequency, float sample_rate,
                          size_t filter_length, AudioBuffer::Channel* buffer);
 
  // Rate of the interpolator section of the rational sampling rate converter.
  size_t up_rate_;
 
  // Rate of the decimator section of the rational sampling rate convereter.
  size_t down_rate_;
 
  // Time variable for the polyphase filter.
  size_t time_modulo_up_rate_;
 
  // Marks the last processed sample of the input.
  size_t last_processed_sample_;
 
  // Number of channels in the |AudioBuffer|s processed.
  size_t num_channels_;
 
  // Number of filter coefficients in each phase of the polyphase filter.
  size_t coeffs_per_phase_;
 
  // Filter coefficients stored in polyphase form.
  AudioBuffer transposed_filter_coeffs_;
 
  // Filter coefficients in planar form, used for calculating the transposed
  // filter.
  AudioBuffer temporary_filter_coeffs_;
 
  // Buffer holding the samples of input required between input buffers.
  AudioBuffer state_;
};
 
}  // namespace vraudio
 
#endif  // RESONANCE_AUDIO_DSP_RESAMPLER_H_