streamtools/digital-filter.hpp

   1 #ifndef _digital_filter__hpp__included__
   2 #define _digital_filter__hpp__included__
   3
   4 #include <iostream>
   5 #include <stdint.h>
   6 #include <vector>
   7 #include <map>
   8 #include <list>
   9
  10 #define AMPLIFIER_GAIN_LINEAR 0
  11 #define AMPLIFIER_GAIN_DB 1
  12 #define AMPLIFIER_ATTENUATION_LINEAR 2
  13 #define AMPLIFIER_ATTENUATION_DB 3
  14
  15 template<typename T>
  16 struct field_characteristics
  17 {
  18         typedef field_characteristics<T> self;
  19         static const T additive_identity;
  20         static const T multiplicative_identity;
  21         static const bool limited;
  22         static const T clip_min;
  23         static const T clip_max;
  24 };
  25
  26 template<typename T>
  27 struct npair
  28 {
  29         typedef typename field_characteristics<T>::self characteristics;
  30         typedef T base_type;
  31
  32         npair()
  33         {
  34                 x = field_characteristics<T>::additive_identity;
  35                 y = field_characteristics<T>::additive_identity;
  36         }
  37
  38         npair(T n)
  39         {
  40                 x = n;
  41                 y = n;
  42         }
  43
  44         npair(T _x, T _y)
  45         {
  46                 x = _x;
  47                 y = _y;
  48         }
  49
  50         ~npair()
  51         {
  52         }
  53
  54         static npair<T> zero()
  55         {
  56                 return npair(field_characteristics<T>::additive_identity);
  57         }
  58
  59         static npair<T> one()
  60         {
  61                 return npair(field_characteristics<T>::multiplicative_identity);
  62         }
  63
  64         T get_x() const
  65         {
  66                 return x;
  67         }
  68
  69         T get_y() const
  70         {
  71                 return y;
  72         }
  73
  74         npair<T> operator+(npair<T> another)
  75         {
  76                 return npair(x + another.x, y + another.y);
  77         }
  78
  79         npair<T> operator-(npair<T> another)
  80         {
  81                 return npair(x - another.x, y - another.y);
  82         }
  83
  84         npair<T> operator-()
  85         {
  86                 return npair(-x, -y);
  87         }
  88
  89         npair<T> operator*(npair<T> another)
  90         {
  91                 return npair(x * another.x, y * another.y);
  92         }
  93
  94         npair<T> operator*(base_type another)
  95         {
  96                 return npair(x * another, y * another);
  97         }
  98
  99         npair<T> operator/(npair<T> another)
 100         {
 101                 return npair(x / another.x, y / another.y);
 102         }
 103
 104 private:
 105         T x;
 106         T y;
 107 };
 108
 109 template<typename T>
 110 std::ostream& operator<< (std::ostream& os, const npair<T>& pair)
 111 {
 112         return os << "(" << pair.get_x() << "," << pair.get_y() << ")";
 113 }
 114
 115 template<typename T>
 116 npair<T> operator*(T another, npair<T> _this)
 117 {
 118         return npair<T>(another * _this.get_x(), another * _this.get_y());
 119 }
 120
 121
 122 typedef npair<double> filter_number_t;
 123 typedef npair<short> sample_number_t;
 124
 125 struct filter
 126 {
 127         virtual ~filter();
 128         virtual filter_number_t operator()(filter_number_t input) = 0;
 129 };
 130
 131
 132 //a0*y0+a1*y1+...+an*yn = b0*x0+b1*x1+...+bm*xm
 133 struct digital_filter : public filter
 134 {
 135         digital_filter(const std::vector<filter_number_t>& num);
 136         digital_filter(const std::vector<filter_number_t>& num, const std::vector<filter_number_t>& denum);
 137         ~digital_filter();
 138         filter_number_t operator()(filter_number_t input);
 139 private:
 140         void init_numerator(const std::vector<filter_number_t>& num);
 141         void init_denumerator(const std::vector<filter_number_t>& num);
 142         std::vector<filter_number_t> filter_numerator;
 143         std::vector<filter_number_t> filter_denumerator;
 144         std::vector<filter_number_t> old_input;
 145         std::vector<filter_number_t> old_output;
 146         uint64_t sample_count;
 147 };
 148
 149 struct amplifier : public filter
 150 {
 151         amplifier(filter_number_t::base_type amount, int type);
 152         ~amplifier();
 153         filter_number_t operator()(filter_number_t input);
 154 private:
 155         filter_number_t::base_type linear_gain;
 156 };
 157
 158 struct silencer : public filter
 159 {
 160         silencer();
 161         ~silencer();
 162         filter_number_t operator()(filter_number_t input);
 163 };
 164
 165 struct composite_filter : public filter
 166 {
 167         composite_filter();
 168         ~composite_filter();
 169         //Filt is deleted when composite_filter is destroyed.
 170         void add(filter& filt);
 171         filter_number_t operator()(filter_number_t input);
 172 private:
 173         std::list<filter*> filters;
 174 };
 175
 176 struct trivial_filter : public filter
 177 {
 178         trivial_filter();
 179         ~trivial_filter();
 180         filter_number_t operator()(filter_number_t input);
 181 };
 182
 183 extern trivial_filter trivial;
 184
 185 sample_number_t downconvert(filter_number_t input, uint64_t& clipped);
 186 filter_number_t upconvert(sample_number_t input);
 187
 188 struct mixer
 189 {
 190         mixer();
 191         ~mixer();
 192
 193         //These release filter on destroy (except for trivial filter).
 194         void set_input_filter(uint32_t permchan, filter& f);
 195         void set_output_filter(filter& f);
 196
 197         void set_channel_volume(uint32_t permchan, filter_number_t volume);
 198         void send_sample(uint32_t permchan, sample_number_t sample);
 199         sample_number_t recv_sample();
 200
 201         uint64_t get_clip_count();
 202 private:
 203         filter& get_input_filter(uint32_t permchan);
 204         filter_number_t get_input_volume(uint32_t permchan);
 205         filter_number_t accumulator;
 206         std::map<uint32_t, filter_number_t> input_volumes;
 207         std::map<uint32_t, filter*> input_filters;
 208         filter* output_filter;
 209         uint64_t clip_count;
 210 };
 211
 212 #endif