propagationline.h

Go to the documentation of this file.

/*
 propagationline.h
 Spatial Audio Library (SAL)
 Copyright (c) 2011, Enzo De Sena
 All rights reserved.
 
 Authors: Enzo De Sena, enzodesena@gmail.com
 
 */

#ifndef SAL_PROPAGATIONLINE_H
#define SAL_PROPAGATIONLINE_H

#include "delayfilter.h"
#include "iirfilter.h"
#include "point.h"
#include "firfilter.h"
#include "salconstants.h"
#include "salutilities.h"

namespace sal {
  

  
class PropagationLine {
public:
  
  PropagationLine(const sal::Length distance, 
                  const sal::Time sampling_frequency, 
                  const sal::Length max_distance = 100.0,
                  const sal::InterpolationType = sal::InterpolationType::kRounding,
                  const bool air_filters_active = false,
                  const bool allow_attenuation_larger_than_one = false,
                  const sal::Length reference_distance = kOneSampleDistance) noexcept;
  
  sal::Sample attenuation() const noexcept;
  
  sal::Length distance() const noexcept;
  
  void SetAttenuation(const sal::Sample,
                      const sal::Time ramp_time = 0.0) noexcept;
  
  inline sal::Time current_latency() const noexcept { return current_latency_; }
  
  inline sal::Time target_latency() const noexcept {
    return latency_smoother_.target_value();
  }
  
  void SetAirFiltersActive(const bool) noexcept;
  
  void Write(const sal::Sample &sample) noexcept;
  
  void Write(const Sample* samples, const Int num_samples) noexcept;
  
  inline sal::Sample Read() const noexcept {
    if (interpolation_type_ == sal::InterpolationType::kLinear) {
      return delay_filter_.FractionalReadAt(current_latency_) * current_attenuation_;
    } else {
      return delay_filter_.ReadAt(mcl::RoundToInt(current_latency_)) * current_attenuation_;
    }
  }
  
  void Read(const Int num_samples, Sample* output_data) const noexcept;
  
  void Tick() noexcept;
  
  void Tick(const Int num_samples) noexcept;
  
  void SetDistance(const sal::Length distance,
                   const sal::Time ramp_time = 0.0) noexcept;
  
  void Reset() noexcept;
  
  static const Length kOneSampleDistance;
  
  static bool Test();
private:
  sal::Time sampling_frequency_;
  DelayFilter delay_filter_;
  sal::Length reference_distance_; 
  bool allow_gain_;
  sal::Sample current_attenuation_;
  sal::Time current_latency_; 
  bool air_filters_active_;
  mcl::FirFilter air_filter_;
  sal::InterpolationType interpolation_type_;
  RampSmoother attenuation_smoother_;
  RampSmoother latency_smoother_;
  
  void Update() noexcept;
  sal::Time ComputeLatency(const sal::Length) noexcept;
  sal::Sample ComputeAttenuation(const sal::Length) noexcept;
  
  static std::vector<sal::Sample> GetAirFilter(sal::Length distance) noexcept;
  static Sample SanitiseAttenuation(const sal::Sample attenuation);
};
  

} // namespace sal
  
#endif