firfilter.h

Go to the documentation of this file.

/*
 MCL
 Copyright (c) 2012-18, Enzo De Sena
 All rights reserved.
 
 Authors: Enzo De Sena, enzodesena@gmail.com
 */

#ifndef MCL_FIRFILTER_H
#define MCL_FIRFILTER_H

#include <vector>

#include "mcltypes.h"
#include "digitalfilter.h"
#include "vectorop.h"

namespace mcl {
class FirFilter : public DigitalFilter {
public:
  FirFilter() noexcept;
  
  FirFilter(const std::vector<Real> B) noexcept;
  
  virtual Real Filter(const Real input_sample) noexcept;
  
  virtual void Filter(const Real* __restrict input_data, const Int num_samples,
                      Real* __restrict output_data) noexcept;
  
  using DigitalFilter::Filter;
  
  void SetImpulseResponse(const std::vector<Real>& impulse_response,
                          const Int update_length = 0) noexcept;
  
  void Reset() noexcept;
  
  std::vector<Real> impulse_response() noexcept;
  
  static FirFilter GainFilter(const Real gain) noexcept;
  
  static bool Test();
  
  static void SpeedTests();
  
  virtual ~FirFilter() {}
  
private:
#ifdef MCL_APPLE_ACCELERATE
  Real FilterAppleDsp(Real input_sample) noexcept;
  void FilterAppleDsp(const Real* __restrict input_data, const Int num_samples,
                      Real* __restrict output_data) noexcept;
#endif
  
  template<class T>
  void GetExtendedInput(const Real* __restrict input_data, const Int num_samples,
                        T* __restrict extended_input_data) {
    
    // Stage 1
    for (Int i=0; i<counter_; ++i) {
      extended_input_data[i] = delay_line_[counter_-i-1];
    }
    
    // Stage 2
    // Starting from counter_ in padded_data
    // Ending in counter_+(length_-counter_-1)
    for (Int i=counter_; i<(length_-1); ++i) {
      extended_input_data[i] = delay_line_[length_-1-(i-counter_)];
    }
    
    // Stage 3
    // Append input signal
    for (Int i=(length_-1); i<(length_-1+num_samples); ++i) {
      extended_input_data[i] = input_data[i-(length_-1)];
    }
  }
  
  Real FilterStraight(Real input_sample) noexcept;
  
  std::vector<Real> FilterSequential(const std::vector<Real>& input) noexcept;
  
  void UpdateCoefficients() noexcept;
  
  std::vector<Real> impulse_response_;
  std::vector<Real> impulse_response_old_;
  Int update_index_;
  Int update_length_;
  
  bool updating_;
  
  /* This is the current vector of coefficients. When the filter is updating
   this will in general be different from impulse_response_. */
  std::vector<Real> coefficients_;
  std::vector<Real> delay_line_;
  Int counter_;
  Int length_;
};
  
  
class GainFilter : public DigitalFilter {
public:
  GainFilter(const Real gain) : gain_(gain) {}
  
  virtual Real Filter(const Real input) noexcept {
    return input*gain_;
  }
  
  virtual void Filter(const Real* input_data, const Int num_samples,
                      Real* output_data) noexcept {
    Multiply(input_data, num_samples, gain_, output_data);
  }
  
  virtual void Reset() {}
private:
  Real gain_;
};

class IdenticalFilter : public DigitalFilter {
public:
  IdenticalFilter() {}
  
  virtual Real Filter(const Real input) noexcept {
    return input;
  }
  
  virtual void Filter(const Real* input_data, const Int num_samples,
                      Real* output_data) noexcept {
    for (Int i=0; i<num_samples; ++i) {
      output_data[i] = input_data[i];
    }
  }
  
  virtual void Reset() {}
};
  
} // namespace mcl


#endif