binauralmic.h

Go to the documentation of this file.

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

#ifndef SAL_BINAURALMIC_H
#define SAL_BINAURALMIC_H

#include <map>
#include <vector>
#include "microphone.h"
#include "saltypes.h"
#include "array.h"
#include "salconstants.h"
#include "firfilter.h"

namespace sal {
  
enum class HeadRefOrientation {
  standard, // Head facing positive x-axis; positive z-axis passing through jaw and then scalp
  y_z  // Head facing positive y-axis; positive z-axis passing through jaw and then scalp
};
  
class BinauralMicInstance;

class BinauralMic : public StereoMicrophone {
public:
  BinauralMic(const mcl::Point& position,
              const mcl::Quaternion orientation,
              const Int update_length,
              const HeadRefOrientation reference_orientation = HeadRefOrientation::standard);
  
  void SetUpdateLength(Int update_length) noexcept { update_length_ = update_length; }
  
  void SetBypass(bool bypass) noexcept;
  
  virtual void Reset() noexcept;
  
  bool IsCoincident() const noexcept { return true; }
  
  Int num_channels() const noexcept { return 2; }
  
  virtual ~BinauralMic() {}
  
  
  virtual void AddPlaneWaveRelative(const Sample* signal,
                                    const Int num_samples,
                                    const mcl::Point& point,
                                    const Int wave_id,
                                    Buffer& output_buffer) noexcept;
  
private:
  
  virtual Signal GetBrir(const Ear ear, const mcl::Point& point) noexcept = 0;
  
  void CreateInstanceIfNotExist(const Int wave_id) noexcept;
  
  std::map<UInt, BinauralMicInstance> instances_;
  
  Int update_length_;
  
  bool bypass_;
  
  friend class BinauralMicInstance;
  
protected:
  
  HeadRefOrientation reference_orientation_;
};


  
class DatabaseBinauralMic : public BinauralMic {
public:
  DatabaseBinauralMic(const mcl::Point& position,
                      const mcl::Quaternion orientation,
                      const Int update_length,
                      const HeadRefOrientation reference_orientation = HeadRefOrientation::standard);
  
  void FilterAll(mcl::DigitalFilter* filter);
  
  virtual ~DatabaseBinauralMic() {}
protected:
  // Database
  std::vector<std::vector<Signal> > hrtf_database_right_;
  std::vector<std::vector<Signal> > hrtf_database_left_;
};
  
  
  
  
class BinauralMicInstance {
private:
  BinauralMicInstance(BinauralMic* base_mic, sal::Int update_length,
                      const HeadRefOrientation reference_orientation = HeadRefOrientation::standard) :
  previous_point_(mcl::Point(NAN, NAN, NAN)),
  base_mic_(base_mic),
  filter_left_(mcl::FirFilter::GainFilter(1.0)),
  filter_right_(mcl::FirFilter::GainFilter(1.0)),
  update_length_(update_length),
  reference_orientation_(reference_orientation) {}
  
  void AddPlaneWaveRelative(const Sample* input_data,
                            const Int num_samples,
                            const mcl::Point& point,
                            Buffer& output_buffer) noexcept;
  
  void UpdateFilter(const mcl::Point& point) noexcept;
  
  mcl::Point previous_point_;
  
  BinauralMic* base_mic_;
  mcl::FirFilter filter_left_;
  mcl::FirFilter filter_right_;
  sal::Int update_length_;
  HeadRefOrientation reference_orientation_;
  
  friend class BinauralMic;
};
  
  
} // namespace sal

#endif