├── .gitignore
├── LICENSE
├── Makefile
├── README-SDL.txt
├── README.md
├── oscilloscoper-0.3-win32
    └── README.md
└── src
    ├── DspFilters
        ├── Bessel.cpp
        ├── Bessel.h
        ├── Biquad.cpp
        ├── Biquad.h
        ├── Butterworth.cpp
        ├── Butterworth.h
        ├── Cascade.cpp
        ├── Cascade.h
        ├── ChebyshevI.cpp
        ├── ChebyshevI.h
        ├── ChebyshevII.cpp
        ├── ChebyshevII.h
        ├── Common.h
        ├── Custom.cpp
        ├── Custom.h
        ├── Design.cpp
        ├── Design.h
        ├── Documentation.cpp
        ├── Dsp.h
        ├── Elliptic.cpp
        ├── Elliptic.h
        ├── Filter.cpp
        ├── Filter.h
        ├── Layout.h
        ├── Legendre.cpp
        ├── Legendre.h
        ├── MathSupplement.h
        ├── Param.cpp
        ├── Params.h
        ├── PoleFilter.cpp
        ├── PoleFilter.h
        ├── RBJ.cpp
        ├── RBJ.h
        ├── RootFinder.cpp
        ├── RootFinder.h
        ├── SmoothedFilter.h
        ├── State.cpp
        ├── State.h
        ├── Types.h
        └── Utilities.h
    ├── Encoder.cpp
    ├── Encoder.hpp
    ├── Main.cpp
    ├── Oscilloscope.cpp
    ├── Oscilloscope.hpp
    ├── Screen.cpp
    ├── Screen.hpp
    ├── Wave.cpp
    └── Wave.hpp


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Compiled Dynamic libraries
12 | *.so
13 | *.dylib
14 | *.dll
15 | 
16 | # Fortran module files
17 | *.mod
18 | *.smod
19 | 
20 | # Compiled Static libraries
21 | *.lai
22 | *.la
23 | *.a
24 | *.lib
25 | 
26 | # Executables
27 | *.exe
28 | *.out
29 | *.app
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Tero Lindeman
 4 | 
 5 | DSP Filters Library and DSP Demo Application Copyright (c) 2009 by Vinnie Falco
 6 | 
 7 | Permission is hereby granted, free of charge, to any person obtaining a copy
 8 | of this software and associated documentation files (the "Software"), to deal
 9 | in the Software without restriction, including without limitation the rights
10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | copies of the Software, and to permit persons to whom the Software is
12 | furnished to do so, subject to the following conditions:
13 | 
14 | The above copyright notice and this permission notice shall be included in all
15 | copies or substantial portions of the Software.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 | SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | oscilloscoper.exe: src/*.cpp src/*.hpp
2 | 	g++ -O3 -o oscilloscoper.exe src/*.cpp src/DspFilters/*.cpp  -I src -I . -I /mingw/include/sdl2 -lmingw32 -lSDL2main -lSDL2.dll -D__STDC_CONSTANT_MACROS -lavcodec -lavutil -lavformat -lavfilter -lavdevice -lswscale -s
3 | 


--------------------------------------------------------------------------------
/README-SDL.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | Please distribute this file with the SDL runtime environment:
 3 | 
 4 | The Simple DirectMedia Layer (SDL for short) is a cross-platform library
 5 | designed to make it easy to write multi-media software, such as games and
 6 | emulators.
 7 | 
 8 | The Simple DirectMedia Layer library source code is available from:
 9 | http://www.libsdl.org/
10 | 
11 | This library is distributed under the terms of the zlib license:
12 | http://www.zlib.net/zlib_license.html
13 | 
14 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # oscilloscoper
 2 | 
 3 | Creates oscilloscope videos from WAV files. Multiple files can be simultaneously rendered in the same video. Output is a raw H.264 stream. You need to use e.g. ffmpeg to mux the video stream with the audio in a playable container like MP4.
 4 | 
 5 | ## Usage
 6 | 
 7 | ```
 8 | oscilloscoper.exe WavFile1.wav WavFile2.wav ...
 9 | ```
10 | 
11 | ### Muxing with ffmpeg
12 | 
13 | ```
14 | oscilloscoper -fps 50 Input.wav
15 | ffmpeg -i Input.wav -r 50 -i Output.h264 -vcodec copy Output.mp4
16 | ```
17 | 
18 | ## Input files
19 | 
20 | Oscilloscoper reads normal PCM RIFF wave files. Stereo files will be reduced into mono files. Oscilloscoper tries to center the current oscilloscope display to zero crossings. For more complex input (with noise etc.) you can use the filtering options to try to stabilize the display.
21 | 
22 | ## Command line options
23 | 
24 | ```-output <Filename>```
25 | Set output filename. Default is Output.h264.
26 | 
27 | ```-width <Video width in pixels>```
28 | ```-height <Video height in pixels>```
29 | Set output stream dimensions. Default is 1920x1080.
30 | 
31 | ```-fps <Frames per second>```
32 | Set output stream frame rate. Default is 60 FPS.
33 | 
34 | ```-bitrate <Bits per second>```
35 | Set output stream bitrate. Default is 8000000.
36 | 
37 | ### Options for input files
38 | 
39 | The following options apply to each input file specified after the option.
40 | 
41 | ```-yscale <Scale>```
42 | Set y-coordinate scaling for the following input files. Can be independently set for each input .WAV file that follow this option. Default is 1.0.
43 | 
44 | ```-filter <Center frequency>```
45 | Enable filter for the following input files and set the bandpass filter center frequency. Filter is disabled by default.
46 | 
47 | ```-bandwidth <Center frequency>```
48 | Enable filter for the following input files and set the bandpass bandwidth. Filter is disabled by default. Default value is 50 Hz.
49 | 
50 | ```-nofilter ```
51 | Disable filtering for the following input files. Filter is disabled by default.
52 | 
53 | ```-channel <channel>```
54 | Pick a single channel from the input file. Uses a mixdown of all channels by default. Note: this option is reset to the default setting after each input file.
55 | 
56 | ### Example
57 | 
58 | ```oscilloscoper -output MyVideo.h264 -fps 50 -yscale 0.5 wav1.wav -yscale 2.5 -channel 0 wav2.wav wav3.wav```
59 | 
60 | This will read the mixdown of ```wav1.wav```, the first channel of ```wav2.wav```, the full mixdown of ```wav3.wav```, scale down the first file to 50 % and scale the second and the third file to 250 %. The resulting video stream ```MyVideo.h264``` will use the default dimensions (1920x1080), the default bitrate (8 Mb/s). The frame rate will be 50 frames per second.
61 | 


--------------------------------------------------------------------------------
/oscilloscoper-0.3-win32/README.md:
--------------------------------------------------------------------------------
 1 | # oscilloscoper
 2 | 
 3 | Creates oscilloscope videos from WAV files. Multiple files can be simultaneously rendered in the same video. Output is a raw H.264 stream. You need to use e.g. ffmpeg to mux the video stream with the audio in a playable container like MP4.
 4 | 
 5 | ## Usage
 6 | 
 7 | ```
 8 | oscilloscoper.exe WavFile1.wav WavFile2.wav ...
 9 | ```
10 | 
11 | ### Muxing with ffmpeg
12 | 
13 | ```
14 | oscilloscoper -fps 50 Input.wav
15 | ffmpeg -i Input.wav -r 50 -i Output.h264 -vcodec copy Output.mp4
16 | ```
17 | 
18 | ## Input files
19 | 
20 | Oscilloscoper reads normal PCM RIFF wave files. Stereo files will be reduced into mono files. Oscilloscoper tries to center the current oscilloscope display to zero crossings. For more complex input (with noise etc.) you can use the filtering options to try to stabilize the display.
21 | 
22 | ## Command line options
23 | 
24 | ```-output <Filename>```
25 | Set output filename. Default is Output.h264.
26 | 
27 | ```-width <Video width in pixels>```
28 | ```-height <Video height in pixels>```
29 | Set output stream dimensions. Default is 1920x1080.
30 | 
31 | ```-fps <Frames per second>```
32 | Set output stream frame rate. Default is 60 FPS.
33 | 
34 | ```-bitrate <Bits per second>```
35 | Set output stream bitrate. Default is 8000000.
36 | 
37 | ### Options for input files
38 | 
39 | The following options apply to each input file specified after the option.
40 | 
41 | ```-yscale <Scale>```
42 | Set y-coordinate scaling for the following input files. Can be independently set for each input .WAV file that follow this option. Default is 1.0.
43 | 
44 | ```-filter <Center frequency>```
45 | Enable filter for the following input files and set the bandpass filter center frequency. Filter is disabled by default.
46 | 
47 | ```-bandwidth <Center frequency>```
48 | Enable filter for the following input files and set the bandpass bandwidth. Filter is disabled by default. Default value is 50 Hz.
49 | 
50 | ```-nofilter ```
51 | Disable filtering for the following input files. Filter is disabled by default.
52 | 
53 | ```-channel <channel>```
54 | Pick a single channel from the input file. Uses a mixdown of all channels by default. Note: this option is reset to the default setting after each input file.
55 | 
56 | ### Example
57 | 
58 | ```oscilloscoper -output MyVideo.h264 -fps 50 -yscale 0.5 wav1.wav -yscale 2.5 -channel 0 wav2.wav wav3.wav```
59 | 
60 | This will read the mixdown of ```wav1.wav```, the first channel of ```wav2.wav```, the full mixdown of ```wav3.wav```, scale down the first file to 50 % and scale the second and the third file to 250 %. The resulting video stream ```MyVideo.h264``` will use the default dimensions (1920x1080), the default bitrate (8 Mb/s). The frame rate will be 50 frames per second.
61 | 


--------------------------------------------------------------------------------
/src/DspFilters/Bessel.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/Bessel.h"
 38 | #include "DspFilters/RootFinder.h"
 39 | 
 40 | namespace Dsp {
 41 | 
 42 | namespace Bessel {
 43 | 
 44 | // returns fact(n) = n!
 45 | static double fact (int n)
 46 | {
 47 |   if (n == 0)
 48 |     return 1;
 49 | 
 50 |   double y = n;
 51 |   for (double m = n; --m;)
 52 |     y *= m;
 53 | 
 54 |   return y;
 55 | }
 56 | 
 57 | // returns the k-th zero based coefficient of the reverse bessel polynomial of degree n
 58 | static double reversebessel (int k, int n)
 59 | {
 60 |   return fact (2 * n - k) / 
 61 |     ((fact (n - k) * fact(k)) * pow(2., n - k));
 62 | }
 63 | 
 64 | //------------------------------------------------------------------------------
 65 | 
 66 | AnalogLowPass::AnalogLowPass ()
 67 |   : m_numPoles (-1)
 68 | {
 69 |   setNormal (0, 1);
 70 | }
 71 | 
 72 | void AnalogLowPass::design (int numPoles,
 73 |                             WorkspaceBase* w)
 74 | {
 75 |   if (m_numPoles != numPoles)
 76 |   {
 77 |     m_numPoles = numPoles;
 78 | 
 79 |     reset ();
 80 | 
 81 |     RootFinderBase& solver (w->roots);
 82 |     for (int i = 0; i < numPoles + 1; ++i)
 83 |       solver.coef()[i] = reversebessel (i, numPoles);
 84 |     solver.solve (numPoles);
 85 | 
 86 |     const int pairs = numPoles / 2;
 87 |     for (int i = 0; i < pairs; ++i)
 88 |     {
 89 |       complex_t c = solver.root()[i];
 90 |       addPoleZeroConjugatePairs (c, infinity());
 91 |     }
 92 | 
 93 |     if (numPoles & 1)
 94 |       add (solver.root()[pairs].real(), infinity());
 95 |   }
 96 | }
 97 | 
 98 | //------------------------------------------------------------------------------
 99 | 
100 | AnalogLowShelf::AnalogLowShelf ()
101 |   : m_numPoles (-1)
102 | {
103 |   setNormal (doublePi, 1);
104 | }
105 | 
106 | void AnalogLowShelf::design (int numPoles,
107 |                              double gainDb,
108 |                              WorkspaceBase* w)
109 | {
110 |   if (m_numPoles != numPoles ||
111 |       m_gainDb != gainDb)
112 |   {
113 |     m_numPoles = numPoles;
114 |     m_gainDb = gainDb;
115 | 
116 |     reset ();
117 | 
118 |     const double G = pow (10., gainDb / 20) - 1;
119 | 
120 |     RootFinderBase& poles (w->roots);
121 |     for (int i = 0; i < numPoles + 1; ++i)
122 |       poles.coef()[i] = reversebessel (i, numPoles);
123 |     poles.solve (numPoles);
124 | 
125 |     RootFinder<50> zeros;
126 |     for (int i = 0; i < numPoles + 1; ++i)
127 |       zeros.coef()[i] = reversebessel (i, numPoles);
128 |     double a0 = reversebessel (0, numPoles);
129 |     zeros.coef()[0] += G * a0;
130 |     zeros.solve (numPoles);
131 | 
132 |     const int pairs = numPoles / 2;
133 |     for (int i = 0; i < pairs; ++i)
134 |     {
135 |       complex_t p = poles.root()[i];
136 |       complex_t z = zeros.root()[i];
137 |       addPoleZeroConjugatePairs (p, z);
138 |     }
139 | 
140 |     if (numPoles & 1)
141 |       add (poles.root()[pairs].real(), zeros.root()[pairs].real());
142 |   }
143 | }
144 | 
145 | //------------------------------------------------------------------------------
146 | 
147 | void LowPassBase::setup (int order,
148 |                          double sampleRate,
149 |                          double cutoffFrequency,
150 |                          WorkspaceBase* w)
151 | {
152 |   m_analogProto.design (order, w);
153 | 
154 |   LowPassTransform (cutoffFrequency / sampleRate,
155 |                     m_digitalProto,
156 |                     m_analogProto);
157 | 
158 |   Cascade::setLayout (m_digitalProto);
159 | }
160 | 
161 | void HighPassBase::setup (int order,
162 |                           double sampleRate,
163 |                           double cutoffFrequency,
164 |                           WorkspaceBase* w)
165 | {
166 |   m_analogProto.design (order, w);
167 | 
168 |   HighPassTransform (cutoffFrequency / sampleRate,
169 |                      m_digitalProto,
170 |                      m_analogProto);
171 | 
172 |   Cascade::setLayout (m_digitalProto);
173 | }
174 | 
175 | void BandPassBase::setup (int order,
176 |                           double sampleRate,
177 |                           double centerFrequency,
178 |                           double widthFrequency,
179 |                           WorkspaceBase* w)
180 | {
181 |   m_analogProto.design (order, w);
182 | 
183 |   BandPassTransform (centerFrequency / sampleRate,
184 |                      widthFrequency / sampleRate,
185 |                      m_digitalProto,
186 |                      m_analogProto);
187 | 
188 |   Cascade::setLayout (m_digitalProto);
189 | }
190 | 
191 | void BandStopBase::setup (int order,
192 |                           double sampleRate,
193 |                           double centerFrequency,
194 |                           double widthFrequency,
195 |                           WorkspaceBase* w)
196 | {
197 |   m_analogProto.design (order, w);
198 | 
199 |   BandStopTransform (centerFrequency / sampleRate,
200 |                      widthFrequency / sampleRate,
201 |                      m_digitalProto,
202 |                      m_analogProto);
203 | 
204 |   Cascade::setLayout (m_digitalProto);
205 | }
206 | 
207 | void LowShelfBase::setup (int order,
208 |                           double sampleRate,
209 |                           double cutoffFrequency,
210 |                           double gainDb,
211 |                           WorkspaceBase* w)
212 | {
213 |   m_analogProto.design (order, gainDb, w);
214 | 
215 |   LowPassTransform (cutoffFrequency / sampleRate,
216 |                     m_digitalProto,
217 |                     m_analogProto);
218 | 
219 |   Cascade::setLayout (m_digitalProto);
220 | }
221 | 
222 | }
223 | 
224 | }
225 | 


--------------------------------------------------------------------------------
/src/DspFilters/Biquad.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/MathSupplement.h"
 38 | #include "DspFilters/Biquad.h"
 39 | 
 40 | namespace Dsp {
 41 | 
 42 | BiquadPoleState::BiquadPoleState (const BiquadBase& s)
 43 | {
 44 |   const double a0 = s.getA0 ();
 45 |   const double a1 = s.getA1 ();
 46 |   const double a2 = s.getA2 ();
 47 |   const double b0 = s.getB0 ();
 48 |   const double b1 = s.getB1 ();
 49 |   const double b2 = s.getB2 ();
 50 | 
 51 |   if (a2 == 0 && b2 == 0)
 52 |   {
 53 |     // single pole
 54 |     poles.first = -a1;
 55 |     zeros.first = -b0 / b1;
 56 |     poles.second = 0;
 57 |     zeros.second = 0;
 58 |   }
 59 |   else
 60 |   {
 61 |     {
 62 |       const complex_t c = sqrt (complex_t (a1 * a1 - 4 * a0 * a2, 0));
 63 |       double d = 2. * a0;
 64 |       poles.first = -(a1 + c) / d;
 65 |       poles.second =  (c - a1) / d;
 66 |       assert (!poles.is_nan());
 67 |     }
 68 | 
 69 |     {
 70 |       const complex_t c = sqrt (complex_t (
 71 |         b1 * b1 - 4 * b0 * b2, 0));
 72 |       double d = 2. * b0;
 73 |       zeros.first = -(b1 + c) / d;
 74 |       zeros.second =  (c - b1) / d;
 75 |       assert (!zeros.is_nan());
 76 |     }
 77 |   }
 78 | 
 79 |   gain = b0 / a0;
 80 | }
 81 | 
 82 | //------------------------------------------------------------------------------
 83 | 
 84 | complex_t BiquadBase::response (double normalizedFrequency) const
 85 | {
 86 |   const double a0 = getA0 ();
 87 |   const double a1 = getA1 ();
 88 |   const double a2 = getA2 ();
 89 |   const double b0 = getB0 ();
 90 |   const double b1 = getB1 ();
 91 |   const double b2 = getB2 ();
 92 | 
 93 |   const double w = 2 * doublePi * normalizedFrequency;
 94 |   const complex_t czn1 = std::polar (1., -w);
 95 |   const complex_t czn2 = std::polar (1., -2 * w);
 96 |   complex_t ch (1);
 97 |   complex_t cbot (1);
 98 | 
 99 |   complex_t ct (b0/a0);
100 |   complex_t cb (1);
101 |   ct = addmul (ct, b1/a0, czn1);
102 |   ct = addmul (ct, b2/a0, czn2);
103 |   cb = addmul (cb, a1/a0, czn1);
104 |   cb = addmul (cb, a2/a0, czn2);
105 |   ch   *= ct;
106 |   cbot *= cb;
107 | 
108 |   return ch / cbot;
109 | }
110 | 
111 | std::vector<PoleZeroPair> BiquadBase::getPoleZeros () const
112 | {
113 |   std::vector<PoleZeroPair> vpz;
114 |   BiquadPoleState bps (*this);
115 |   vpz.push_back (bps);
116 |   return vpz;
117 | }
118 | 
119 | void BiquadBase::setCoefficients (double a0, double a1, double a2,
120 |                                   double b0, double b1, double b2)
121 | {
122 |   assert (!Dsp::is_nan (a0) && !Dsp::is_nan (a1) && !Dsp::is_nan (a2) &&
123 |           !Dsp::is_nan (b0) && !Dsp::is_nan (b1) && !Dsp::is_nan (b2));
124 | 
125 |   m_a0 = a0;
126 |   m_a1 = a1/a0;
127 |   m_a2 = a2/a0;
128 |   m_b0 = b0/a0;
129 |   m_b1 = b1/a0;
130 |   m_b2 = b2/a0;
131 | }
132 | 
133 | void BiquadBase::setOnePole (complex_t pole, complex_t zero)
134 | {
135 | #if 0
136 |   pole = adjust_imag (pole);
137 |   zero = adjust_imag (zero);
138 | #else
139 |   assert (pole.imag() == 0); 
140 |   assert (zero.imag() == 0);
141 | #endif
142 |   
143 |   const double a0 = 1;
144 |   const double a1 = -pole.real();
145 |   const double a2 = 0;
146 |   const double b0 = -zero.real();
147 |   const double b1 = 1;
148 |   const double b2 = 0;
149 | 
150 |   setCoefficients (a0, a1, a2, b0, b1, b2);
151 | }
152 | 
153 | void BiquadBase::setTwoPole (complex_t pole1, complex_t zero1,
154 |                              complex_t pole2, complex_t zero2)
155 | {
156 | #if 0
157 |   pole1 = adjust_imag (pole1);
158 |   pole2 = adjust_imag (pole2);
159 |   zero1 = adjust_imag (zero1);
160 |   zero2 = adjust_imag (zero2);
161 | #endif
162 | 
163 |   const double a0 = 1;
164 |   double a1;
165 |   double a2;
166 | 
167 |   if (pole1.imag() != 0)
168 |   {
169 |     assert (pole2 == std::conj (pole1));
170 | 
171 |     a1 = -2 * pole1.real();
172 |     a2 = std::norm (pole1);
173 |   }
174 |   else
175 |   {
176 |     assert (pole2.imag() == 0);
177 | 
178 |     a1 = -(pole1.real() + pole2.real());
179 |     a2 =   pole1.real() * pole2.real();
180 |   }
181 | 
182 |   const double b0 = 1;
183 |   double b1;
184 |   double b2;
185 | 
186 |   if (zero1.imag() != 0)
187 |   {
188 |     assert (zero2 == std::conj (zero1));
189 | 
190 |     b1 = -2 * zero1.real();
191 |     b2 = std::norm (zero1);
192 |   }
193 |   else
194 |   {
195 |     assert (zero2.imag() == 0);
196 | 
197 |     b1 = -(zero1.real() + zero2.real());
198 |     b2 =   zero1.real() * zero2.real();
199 |   }
200 | 
201 |   setCoefficients (a0, a1, a2, b0, b1, b2);
202 | }
203 | 
204 | void BiquadBase::setPoleZeroForm (const BiquadPoleState& bps)
205 | {
206 |   setPoleZeroPair (bps);
207 |   applyScale (bps.gain);
208 | }
209 | 
210 | void BiquadBase::setIdentity ()
211 | {
212 |   setCoefficients (1, 0, 0, 1, 0, 0);
213 | }
214 | 
215 | void BiquadBase::applyScale (double scale)
216 | {
217 |   m_b0 *= scale;
218 |   m_b1 *= scale;
219 |   m_b2 *= scale;
220 | }
221 | 
222 | //------------------------------------------------------------------------------
223 | 
224 | Biquad::Biquad ()
225 | {
226 | }
227 | 
228 | // Construct a second order section from a pair of poles and zeroes
229 | Biquad::Biquad (const BiquadPoleState& bps)
230 | {
231 |   setPoleZeroForm (bps);
232 | }
233 | 
234 | //------------------------------------------------------------------------------
235 | 
236 | }
237 | 


--------------------------------------------------------------------------------
/src/DspFilters/Biquad.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_BIQUAD_H
 37 | #define DSPFILTERS_BIQUAD_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/MathSupplement.h"
 41 | #include "DspFilters/Types.h"
 42 | 
 43 | namespace Dsp {
 44 | 
 45 | struct BiquadPoleState;
 46 | 
 47 | /*
 48 |  * Holds coefficients for a second order Infinite Impulse Response
 49 |  * digital filter. This is the building block for all IIR filters.
 50 |  *
 51 |  */
 52 | 
 53 | // Factored interface to prevent outsiders from fiddling
 54 | class BiquadBase
 55 | {
 56 | public:
 57 |   template <class StateType>
 58 |   struct State : StateType, private DenormalPrevention
 59 |   {
 60 |     template <typename Sample>
 61 |     inline Sample process (const Sample in, const BiquadBase& b)
 62 |     {
 63 |       return static_cast<Sample> (StateType::process1 (in, b, ac()));
 64 |     }
 65 |   };
 66 | 
 67 | public:
 68 |   // Calculate filter response at the given normalized frequency.
 69 |   complex_t response (double normalizedFrequency) const;
 70 | 
 71 |   std::vector<PoleZeroPair> getPoleZeros () const;
 72 | 
 73 |   double getA0 () const { return m_a0; }
 74 |   double getA1 () const { return m_a1*m_a0; }
 75 |   double getA2 () const { return m_a2*m_a0; }
 76 |   double getB0 () const { return m_b0*m_a0; }
 77 |   double getB1 () const { return m_b1*m_a0; }
 78 |   double getB2 () const { return m_b2*m_a0; }
 79 | 
 80 |   // Process a block of samples in the given form
 81 |   template <class StateType, typename Sample>
 82 |   void process (int numSamples, Sample* dest, StateType& state) const
 83 |   {
 84 |     while (--numSamples >= 0)
 85 |       *dest++ = state.process (*dest, *this);
 86 |   }
 87 | 
 88 | protected:
 89 |   //
 90 |   // These are protected so you can't mess with RBJ biquads
 91 |   //
 92 | 
 93 |   void setCoefficients (double a0, double a1, double a2,
 94 |                         double b0, double b1, double b2);
 95 | 
 96 |   void setOnePole (complex_t pole, complex_t zero);
 97 | 
 98 |   void setTwoPole (complex_t pole1, complex_t zero1,
 99 |                    complex_t pole2, complex_t zero2);
100 | 
101 |   void setPoleZeroPair (const PoleZeroPair& pair)
102 |   {
103 |     if (pair.isSinglePole ())
104 |       setOnePole (pair.poles.first, pair.zeros.first);
105 |     else
106 |       setTwoPole (pair.poles.first, pair.zeros.first,
107 |                   pair.poles.second, pair.zeros.second);
108 |   }
109 | 
110 |   void setPoleZeroForm (const BiquadPoleState& bps);
111 | 
112 |   void setIdentity ();
113 | 
114 |   void applyScale (double scale);
115 | 
116 | public:
117 |   double m_a0;
118 |   double m_a1;
119 |   double m_a2;
120 |   double m_b1;
121 |   double m_b2;
122 |   double m_b0;
123 | };
124 | 
125 | //------------------------------------------------------------------------------
126 | 
127 | // Expresses a biquad as a pair of pole/zeros, with gain
128 | // values so that the coefficients can be reconstructed precisely.
129 | struct BiquadPoleState : PoleZeroPair
130 | {
131 |   BiquadPoleState () { }
132 | 
133 |   explicit BiquadPoleState (const BiquadBase& s);
134 | 
135 |   double gain;
136 | };
137 | 
138 | // More permissive interface for fooling around
139 | class Biquad : public BiquadBase
140 | {
141 | public:
142 |   Biquad ();
143 | 
144 |   explicit Biquad (const BiquadPoleState& bps);
145 | 
146 | public:
147 |   // Process a block of samples, interpolating from the old section's coefficients
148 |   // to this section's coefficients, over numSamples. This implements smooth
149 |   // parameter changes.
150 | 
151 |   template <class StateType, typename Sample>
152 |   void smoothProcess1 (int numSamples,
153 |                        Sample* dest,
154 |                        StateType& state,
155 |                        Biquad sectionPrev) const 
156 |   {
157 |     double t = 1. / numSamples;
158 |     double da1 = (m_a1 - sectionPrev.m_a1) * t;
159 |     double da2 = (m_a2 - sectionPrev.m_a2) * t;
160 |     double db0 = (m_b0 - sectionPrev.m_b0) * t;
161 |     double db1 = (m_b1 - sectionPrev.m_b1) * t;
162 |     double db2 = (m_b2 - sectionPrev.m_b2) * t;
163 | 
164 |     while (--numSamples >= 0)
165 |     {
166 |       sectionPrev.m_a1 += da1;
167 |       sectionPrev.m_a2 += da2;
168 |       sectionPrev.m_b0 += db0;
169 |       sectionPrev.m_b1 += db1;
170 |       sectionPrev.m_b2 += db2;
171 | 
172 |       *dest++ = state.process (*dest, sectionPrev);
173 |     }
174 |   }
175 | 
176 |   // Process a block of samples, interpolating from the old section's pole/zeros
177 |   // to this section's pole/zeros, over numSamples. The interpolation is done
178 |   // in the z-plane using polar coordinates.
179 |   template <class StateType, typename Sample>
180 |   void smoothProcess2 (int numSamples,
181 |                        Sample* dest,
182 |                        StateType& state,
183 |                        BiquadPoleState zPrev) const 
184 |   {
185 |     BiquadPoleState z (*this);
186 |     double t = 1. / numSamples;
187 |     complex_t dp0 = (z.poles.first  - zPrev.poles.first) * t;
188 |     complex_t dp1 = (z.poles.second - zPrev.poles.second) * t;
189 |     complex_t dz0 = (z.zeros.first  - zPrev.zeros.first) * t;
190 |     complex_t dz1 = (z.zeros.second - zPrev.zeros.second) * t;
191 |     double dg = (z.gain - zPrev.gain) * t;
192 | 
193 |     while (--numSamples >= 0)
194 |     {
195 |       zPrev.poles.first += dp0;
196 |       zPrev.poles.second += dp1;
197 |       zPrev.zeros.first += dz0;
198 |       zPrev.zeros.second += dz1;
199 |       zPrev.gain += dg;
200 | 
201 |       *dest++ = state.process (*dest, Biquad (zPrev));
202 |     }
203 |   }
204 | 
205 | public:
206 |   // Export these as public
207 | 
208 |   void setOnePole (complex_t pole, complex_t zero)
209 |   {
210 |     BiquadBase::setOnePole (pole, zero);
211 |   }
212 | 
213 |   void setTwoPole (complex_t pole1, complex_t zero1,
214 |                    complex_t pole2, complex_t zero2)
215 |   {
216 |     BiquadBase::setTwoPole (pole1, zero1, pole2, zero2);
217 |   }
218 | 
219 |   void setPoleZeroPair (const PoleZeroPair& pair)
220 |   {
221 |     BiquadBase::setPoleZeroPair (pair);
222 |   }
223 | 
224 |   void applyScale (double scale)
225 |   {
226 |     BiquadBase::applyScale (scale);
227 |   }
228 | };
229 | 
230 | }
231 | 
232 | #endif
233 | 


--------------------------------------------------------------------------------
/src/DspFilters/Butterworth.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/Butterworth.h"
 38 | 
 39 | namespace Dsp {
 40 | 
 41 | namespace Butterworth {
 42 | 
 43 | AnalogLowPass::AnalogLowPass ()
 44 |   : m_numPoles (-1)
 45 | {
 46 |   setNormal (0, 1);
 47 | }
 48 | 
 49 | void AnalogLowPass::design (int numPoles)
 50 | {
 51 |   if (m_numPoles != numPoles)
 52 |   {
 53 |     m_numPoles = numPoles;
 54 | 
 55 |     reset ();
 56 | 
 57 |     const double n2 = 2 * numPoles;
 58 |     const int pairs = numPoles / 2;
 59 |     for (int i = 0; i < pairs; ++i)
 60 |     {
 61 |       complex_t c = std::polar (1., doublePi_2 + (2 * i + 1) * doublePi / n2);
 62 |       addPoleZeroConjugatePairs (c, infinity());
 63 |     }
 64 | 
 65 |     if (numPoles & 1)
 66 |       add (-1, infinity());
 67 |   }
 68 | }
 69 | 
 70 | //------------------------------------------------------------------------------
 71 | 
 72 | AnalogLowShelf::AnalogLowShelf ()
 73 |   : m_numPoles (-1)
 74 | {
 75 |   setNormal (doublePi, 1);
 76 | }
 77 | 
 78 | void AnalogLowShelf::design (int numPoles, double gainDb)
 79 | {
 80 |   if (m_numPoles != numPoles ||
 81 |       m_gainDb != gainDb)
 82 |   {
 83 |     m_numPoles = numPoles;
 84 |     m_gainDb = gainDb;
 85 | 
 86 |     reset ();
 87 | 
 88 |     const double n2 = numPoles * 2;
 89 |     const double g = pow (pow (10., gainDb/20), 1. / n2);
 90 |     const double gp = -1. / g;
 91 |     const double gz = -g;
 92 | 
 93 |     const int pairs = numPoles / 2;
 94 |     for (int i = 1; i <= pairs; ++i)
 95 |     {
 96 |       const double theta = doublePi * (0.5 - (2 * i - 1) / n2);
 97 |       addPoleZeroConjugatePairs (std::polar (gp, theta), std::polar (gz, theta));
 98 |     }
 99 |     
100 |     if (numPoles & 1)
101 |       add (gp, gz);
102 |   }
103 | }
104 | 
105 | //------------------------------------------------------------------------------
106 | 
107 | void LowPassBase::setup (int order,
108 |                          double sampleRate,
109 |                          double cutoffFrequency)
110 | {
111 |   m_analogProto.design (order);
112 | 
113 |   LowPassTransform (cutoffFrequency / sampleRate,
114 |                     m_digitalProto,
115 |                     m_analogProto);
116 | 
117 |   Cascade::setLayout (m_digitalProto);
118 | }
119 | 
120 | void HighPassBase::setup (int order,
121 |                           double sampleRate,
122 |                           double cutoffFrequency)
123 | {
124 |   m_analogProto.design (order);
125 | 
126 |   HighPassTransform (cutoffFrequency / sampleRate,
127 |                      m_digitalProto,
128 |                      m_analogProto);
129 | 
130 |   Cascade::setLayout (m_digitalProto);
131 | }
132 | 
133 | void BandPassBase::setup (int order,
134 |                           double sampleRate,
135 |                           double centerFrequency,
136 |                           double widthFrequency)
137 | {
138 |   m_analogProto.design (order);
139 | 
140 |   BandPassTransform (centerFrequency / sampleRate,
141 |                      widthFrequency / sampleRate,
142 |                      m_digitalProto,
143 |                      m_analogProto);
144 | 
145 |   Cascade::setLayout (m_digitalProto);
146 | }
147 | 
148 | void BandStopBase::setup (int order,
149 |                           double sampleRate,
150 |                           double centerFrequency,
151 |                           double widthFrequency)
152 | {
153 |   m_analogProto.design (order);
154 | 
155 |   BandStopTransform (centerFrequency / sampleRate,
156 |                      widthFrequency / sampleRate,
157 |                      m_digitalProto,
158 |                      m_analogProto);
159 | 
160 |   Cascade::setLayout (m_digitalProto);
161 | }
162 | 
163 | void LowShelfBase::setup (int order,
164 |                          double sampleRate,
165 |                          double cutoffFrequency,
166 |                          double gainDb)
167 | {
168 |   m_analogProto.design (order, gainDb);
169 | 
170 |   LowPassTransform (cutoffFrequency / sampleRate,
171 |                     m_digitalProto,
172 |                     m_analogProto);
173 | 
174 |   Cascade::setLayout (m_digitalProto);
175 | }
176 | 
177 | void HighShelfBase::setup (int order,
178 |                            double sampleRate,
179 |                            double cutoffFrequency,
180 |                            double gainDb)
181 | {
182 |   m_analogProto.design (order, gainDb);
183 | 
184 |   HighPassTransform (cutoffFrequency / sampleRate,
185 |                      m_digitalProto,
186 |                      m_analogProto);
187 | 
188 |   Cascade::setLayout (m_digitalProto);
189 | }
190 | 
191 | void BandShelfBase::setup (int order,
192 |                            double sampleRate,
193 |                            double centerFrequency,
194 |                            double widthFrequency,
195 |                            double gainDb)
196 | {
197 |   m_analogProto.design (order, gainDb);
198 | 
199 |   BandPassTransform (centerFrequency / sampleRate,
200 |                      widthFrequency / sampleRate,
201 |                      m_digitalProto,
202 |                      m_analogProto);
203 | 
204 |   // HACK!
205 |   m_digitalProto.setNormal (((centerFrequency/sampleRate) < 0.25) ? doublePi : 0, 1);
206 | 
207 |   Cascade::setLayout (m_digitalProto);
208 | }
209 | 
210 | }
211 | 
212 | }
213 | 


--------------------------------------------------------------------------------
/src/DspFilters/Cascade.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/Cascade.h"
 38 | 
 39 | namespace Dsp {
 40 | 
 41 | Cascade::Cascade ()
 42 |   : m_numStages (0)
 43 |   , m_maxStages (0)
 44 |   , m_stageArray (0)
 45 | {
 46 | }
 47 | 
 48 | void Cascade::setCascadeStorage (const Storage& storage)
 49 | {
 50 |   m_numStages = 0;
 51 |   m_maxStages = storage.maxStages;
 52 |   m_stageArray = storage.stageArray;
 53 | }
 54 | 
 55 | complex_t Cascade::response (double normalizedFrequency) const
 56 | {
 57 |   double w = 2 * doublePi * normalizedFrequency;
 58 |   const complex_t czn1 = std::polar (1., -w);
 59 |   const complex_t czn2 = std::polar (1., -2 * w);
 60 |   complex_t ch (1);
 61 |   complex_t cbot (1);
 62 | 
 63 |   const Biquad* stage = m_stageArray;
 64 |   for (int i = m_numStages; --i >=0; ++stage)
 65 |   {
 66 |     complex_t cb (1);
 67 |     complex_t ct    (stage->getB0()/stage->getA0());
 68 |     ct = addmul (ct, stage->getB1()/stage->getA0(), czn1);
 69 |     ct = addmul (ct, stage->getB2()/stage->getA0(), czn2);
 70 |     cb = addmul (cb, stage->getA1()/stage->getA0(), czn1);
 71 |     cb = addmul (cb, stage->getA2()/stage->getA0(), czn2);
 72 |     ch   *= ct;
 73 |     cbot *= cb;
 74 |   }
 75 | 
 76 |   return ch / cbot;
 77 | }
 78 | 
 79 | std::vector<PoleZeroPair> Cascade::getPoleZeros () const
 80 | {
 81 |   std::vector<PoleZeroPair> vpz;
 82 |   vpz.reserve (m_numStages);
 83 | 
 84 |   const Stage* stage = m_stageArray;
 85 |   for (int i = m_numStages; --i >=0;)
 86 |   {
 87 |     BiquadPoleState bps (*stage++);
 88 |     assert (!bps.isSinglePole() || i == 0);
 89 |     vpz.push_back (bps);
 90 |   }
 91 | 
 92 |   return vpz;
 93 | }
 94 | 
 95 | void Cascade::applyScale (double scale)
 96 | {
 97 |   // For higher order filters it might be helpful
 98 |   // to spread this factor between all the stages.
 99 |   assert (m_numStages > 0);
100 |   m_stageArray->applyScale (scale);
101 | }
102 | 
103 | void Cascade::setLayout (const LayoutBase& proto)
104 | {
105 |   const int numPoles = proto.getNumPoles();
106 |   m_numStages = (numPoles + 1)/ 2;
107 |   assert (m_numStages <= m_maxStages);
108 | 
109 |   Biquad* stage = m_stageArray;
110 |   for (int i = 0; i < m_numStages; ++i, ++stage)
111 |     stage->setPoleZeroPair (proto[i]);
112 |   
113 |   applyScale (proto.getNormalGain() /
114 |               std::abs (response (proto.getNormalW() / (2 * doublePi))));
115 | }
116 | 
117 | }
118 | 
119 | 


--------------------------------------------------------------------------------
/src/DspFilters/Cascade.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_CASCADE_H
 37 | #define DSPFILTERS_CASCADE_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Biquad.h"
 41 | #include "DspFilters/Filter.h"
 42 | #include "DspFilters/Layout.h"
 43 | #include "DspFilters/MathSupplement.h"
 44 | 
 45 | namespace Dsp {
 46 | 
 47 | /*
 48 |  * Holds coefficients for a cascade of second order sections.
 49 |  *
 50 |  */
 51 | 
 52 | // Factored implementation to reduce template instantiations
 53 | class Cascade
 54 | {
 55 | public:
 56 |   template <class StateType>
 57 |   class StateBase : private DenormalPrevention
 58 |   {
 59 |   public:
 60 |     template <typename Sample>
 61 |     inline Sample process (const Sample in, const Cascade& c)
 62 |     {
 63 |       double out = in;
 64 |       StateType* state = m_stateArray;
 65 |       Biquad const* stage = c.m_stageArray;
 66 |       const double vsa = ac();
 67 |       int i = c.m_numStages - 1;
 68 |         out = (state++)->process1 (out, *stage++, vsa);
 69 |       for (; --i >= 0;)
 70 |         out = (state++)->process1 (out, *stage++, 0);
 71 |       //for (int i = c.m_numStages; --i >= 0; ++state, ++stage)
 72 |       //  out = state->process1 (out, *stage, vsa);
 73 |       return static_cast<Sample> (out);
 74 |     }
 75 | 
 76 |   protected:
 77 |     StateBase (StateType* stateArray)
 78 |       : m_stateArray (stateArray)
 79 |     {
 80 |     }
 81 | 
 82 |   protected:
 83 |     StateType* m_stateArray;
 84 |   };
 85 | 
 86 |   struct Stage : Biquad
 87 |   {
 88 |   };
 89 | 
 90 |   struct Storage
 91 |   {
 92 |     Storage (int maxStages_, Stage* stageArray_)
 93 |       : maxStages (maxStages_)
 94 |       , stageArray (stageArray_)
 95 |     {
 96 |     }
 97 | 
 98 |     int maxStages;
 99 |     Stage* stageArray;
100 |   };
101 | 
102 |   int getNumStages () const
103 |   {
104 |     return m_numStages;
105 |   }
106 | 
107 |   const Stage& operator[] (int index)
108 |   {
109 |     assert (index >= 0 && index <= m_numStages);
110 |     return m_stageArray[index];
111 |   }
112 | 
113 | public:
114 |   // Calculate filter response at the given normalized frequency.
115 |   complex_t response (double normalizedFrequency) const;
116 | 
117 |   std::vector<PoleZeroPair> getPoleZeros () const;
118 | 
119 |   // Process a block of samples in the given form
120 |   template <class StateType, typename Sample>
121 |   void process (int numSamples, Sample* dest, StateType& state) const
122 |   {
123 |     while (--numSamples >= 0)
124 |       *dest++ = state.process (*dest, *this);
125 |   }
126 | 
127 | protected:
128 |   Cascade ();
129 | 
130 |   void setCascadeStorage (const Storage& storage);
131 | 
132 |   void applyScale (double scale);
133 |   void setLayout (const LayoutBase& proto);
134 | 
135 | private:
136 |   int m_numStages;
137 |   int m_maxStages;
138 |   Stage* m_stageArray;
139 | };
140 | 
141 | //------------------------------------------------------------------------------
142 | 
143 | // Storage for Cascade
144 | template <int MaxStages>
145 | class CascadeStages
146 | {
147 | public:
148 |   template <class StateType>
149 |   class State : public Cascade::StateBase <StateType>
150 |   {
151 |   public:
152 |     State() : Cascade::StateBase <StateType> (m_states)
153 |     {
154 |       Cascade::StateBase <StateType>::m_stateArray = m_states;
155 |       reset ();
156 |     }
157 | 
158 |     void reset ()
159 |     {
160 |       StateType* state = m_states;
161 |       for (int i = MaxStages; --i >= 0; ++state)
162 |         state->reset();
163 |     }
164 | 
165 |   private:
166 |     StateType m_states[MaxStages];
167 |   };
168 | 
169 |   /*@Internal*/
170 |   Cascade::Storage getCascadeStorage()
171 |   {
172 |     return Cascade::Storage (MaxStages, m_stages);
173 |   }
174 | 
175 | private:
176 |   Cascade::Stage m_stages[MaxStages];
177 | };
178 | 
179 | }
180 | 
181 | #endif
182 | 


--------------------------------------------------------------------------------
/src/DspFilters/ChebyshevI.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/ChebyshevI.h"
 38 | 
 39 | namespace Dsp {
 40 | 
 41 | namespace ChebyshevI {
 42 | 
 43 | AnalogLowPass::AnalogLowPass ()
 44 |   : m_numPoles (-1)
 45 | {
 46 | }
 47 | 
 48 | void AnalogLowPass::design (int numPoles,
 49 |                             double rippleDb)
 50 | {
 51 |   if (m_numPoles != numPoles ||
 52 |       m_rippleDb != rippleDb)
 53 |   {
 54 |     m_numPoles = numPoles;
 55 |     m_rippleDb = rippleDb;
 56 | 
 57 |     reset ();
 58 | 
 59 |     const double eps = std::sqrt (1. / std::exp (-rippleDb * 0.1 * doubleLn10) - 1);
 60 |     const double v0 = asinh (1 / eps) / numPoles;
 61 |     const double sinh_v0 = -sinh (v0);
 62 |     const double cosh_v0 = cosh (v0);
 63 | 
 64 |     const double n2 = 2 * numPoles;
 65 |     const int pairs = numPoles / 2;
 66 |     for (int i = 0; i < pairs; ++i)
 67 |     {
 68 |       const int k = 2 * i + 1 - numPoles;
 69 |       double a = sinh_v0 * cos (k * doublePi / n2);
 70 |       double b = cosh_v0 * sin (k * doublePi / n2);
 71 | 
 72 |       //addPoleZero (complex_t (a, b), infinity());
 73 |       //addPoleZero (complex_t (a, -b), infinity());
 74 |       addPoleZeroConjugatePairs (complex_t (a, b), infinity());
 75 |     }
 76 | 
 77 |     if (numPoles & 1)
 78 |     {
 79 |       add (complex_t (sinh_v0, 0), infinity());
 80 |       setNormal (0, 1);
 81 |     }
 82 |     else
 83 |     {
 84 |       setNormal (0, pow (10, -rippleDb/20.));
 85 |     }
 86 |   }
 87 | }
 88 | 
 89 | //------------------------------------------------------------------------------
 90 | 
 91 | //
 92 | // Chebyshev Type I low pass shelf prototype
 93 | // From "High-Order Digital Parametric Equalizer Design"
 94 | // Sophocles J. Orfanidis
 95 | // http://www.ece.rutgers.edu/~orfanidi/ece521/hpeq.pdf
 96 | //
 97 | 
 98 | AnalogLowShelf::AnalogLowShelf ()
 99 | {
100 |   setNormal (doublePi, 1);
101 | }
102 | 
103 | void AnalogLowShelf::design (int numPoles,
104 |                              double gainDb,
105 |                              double rippleDb)
106 | {
107 |   if (m_numPoles != numPoles ||
108 |       m_rippleDb != rippleDb ||
109 |       m_gainDb != gainDb)
110 |   {
111 |     m_numPoles = numPoles;
112 |     m_rippleDb = rippleDb;
113 |     m_gainDb = gainDb;
114 | 
115 |     reset ();
116 | 
117 |     gainDb = -gainDb;
118 | 
119 |     if (rippleDb >= fabs(gainDb))
120 |       rippleDb = fabs (gainDb);
121 |     if (gainDb<0)
122 |       rippleDb = -rippleDb;
123 | 
124 |     const double G  = std::pow (10., gainDb / 20.0 );
125 |     const double Gb = std::pow (10., (gainDb - rippleDb) / 20.0);
126 |     const double G0 = 1;
127 |     const double g0 = pow (G0 , 1. / numPoles);
128 | 
129 |     double eps;
130 |     if (Gb != G0 )
131 |       eps = sqrt((G*G-Gb*Gb)/(Gb*Gb-G0*G0));
132 |     else
133 |       eps = G-1; // This is surely wrong
134 | 
135 |     const double b = pow (G/eps+Gb*sqrt(1+1/(eps*eps)), 1./numPoles);
136 |     const double u = log (b / g0);
137 |     const double v = log (pow (1. / eps+sqrt(1+1/(eps*eps)),1./numPoles));
138 |     
139 |     const double sinh_u = sinh (u);
140 |     const double sinh_v = sinh (v);
141 |     const double cosh_u = cosh (u);
142 |     const double cosh_v = cosh (v);
143 |     const double n2 = 2 * numPoles;
144 |     const int pairs = numPoles / 2;
145 |     for (int i = 1; i <= pairs; ++i)
146 |     {
147 |       const double a = doublePi * (2 * i - 1) / n2;
148 |       const double sn = sin (a);
149 |       const double cs = cos (a);
150 |       addPoleZeroConjugatePairs (complex_t (-sn * sinh_u, cs * cosh_u),
151 |                                        complex_t (-sn * sinh_v, cs * cosh_v));
152 |     }
153 | 
154 |     if (numPoles & 1)
155 |       add (-sinh_u, -sinh_v);
156 |   }
157 | }
158 | 
159 | //------------------------------------------------------------------------------
160 | 
161 | void LowPassBase::setup (int order,
162 |                          double sampleRate,
163 |                          double cutoffFrequency,
164 |                          double rippleDb)
165 | {
166 |   m_analogProto.design (order, rippleDb);
167 | 
168 |   LowPassTransform (cutoffFrequency / sampleRate,
169 |                     m_digitalProto,
170 |                     m_analogProto);
171 | 
172 |   Cascade::setLayout (m_digitalProto);
173 | }
174 | 
175 | void HighPassBase::setup (int order,
176 |                           double sampleRate,
177 |                           double cutoffFrequency,
178 |                           double rippleDb)
179 | {
180 |   m_analogProto.design (order, rippleDb);
181 | 
182 |   HighPassTransform (cutoffFrequency / sampleRate,
183 |                      m_digitalProto,
184 |                      m_analogProto);
185 | 
186 |   Cascade::setLayout (m_digitalProto);
187 | }
188 | 
189 | void BandPassBase::setup (int order,
190 |                           double sampleRate,
191 |                           double centerFrequency,
192 |                           double widthFrequency,
193 |                           double rippleDb)
194 | {
195 |   m_analogProto.design (order, rippleDb);
196 | 
197 |   BandPassTransform (centerFrequency / sampleRate,
198 |                      widthFrequency / sampleRate,
199 |                      m_digitalProto,
200 |                      m_analogProto);
201 | 
202 |   Cascade::setLayout (m_digitalProto);
203 | }
204 | 
205 | void BandStopBase::setup (int order,
206 |                           double sampleRate,
207 |                           double centerFrequency,
208 |                           double widthFrequency,
209 |                           double rippleDb)
210 | {
211 |   m_analogProto.design (order, rippleDb);
212 | 
213 |   BandStopTransform (centerFrequency / sampleRate,
214 |                      widthFrequency / sampleRate,
215 |                      m_digitalProto,
216 |                      m_analogProto);
217 | 
218 |   Cascade::setLayout (m_digitalProto);
219 | }
220 | 
221 | void LowShelfBase::setup (int order,
222 |                           double sampleRate,
223 |                           double cutoffFrequency,
224 |                           double gainDb,
225 |                           double rippleDb)
226 | {
227 |   m_analogProto.design (order, gainDb, rippleDb);
228 | 
229 |   LowPassTransform (cutoffFrequency / sampleRate,
230 |                     m_digitalProto,
231 |                     m_analogProto);
232 | 
233 |   Cascade::setLayout (m_digitalProto);
234 | }
235 | 
236 | void HighShelfBase::setup (int order,
237 |                            double sampleRate,
238 |                            double cutoffFrequency,
239 |                            double gainDb,
240 |                            double rippleDb)
241 | {
242 |   m_analogProto.design (order, gainDb, rippleDb);
243 | 
244 |   HighPassTransform (cutoffFrequency / sampleRate,
245 |                      m_digitalProto,
246 |                      m_analogProto);
247 | 
248 |   Cascade::setLayout (m_digitalProto);
249 | }
250 | 
251 | void BandShelfBase::setup (int order,
252 |                            double sampleRate,
253 |                            double centerFrequency,
254 |                            double widthFrequency,
255 |                            double gainDb,
256 |                            double rippleDb)
257 | {
258 |   m_analogProto.design (order, gainDb, rippleDb);
259 | 
260 |   BandPassTransform (centerFrequency / sampleRate,
261 |                      widthFrequency / sampleRate,
262 |                      m_digitalProto,
263 |                      m_analogProto);
264 | 
265 |   m_digitalProto.setNormal (((centerFrequency/sampleRate) < 0.25) ? doublePi : 0, 1);
266 | 
267 |   Cascade::setLayout (m_digitalProto);
268 | }
269 | 
270 | }
271 | 
272 | }
273 | 


--------------------------------------------------------------------------------
/src/DspFilters/ChebyshevII.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/ChebyshevII.h"
 38 | 
 39 | namespace Dsp {
 40 | 
 41 | namespace ChebyshevII {
 42 | 
 43 | // "Chebyshev Filter Properties"
 44 | // http://cnx.org/content/m16906/latest/
 45 | 
 46 | AnalogLowPass::AnalogLowPass ()
 47 |   : m_numPoles (-1)
 48 | {
 49 |   setNormal (0, 1);
 50 | }
 51 | 
 52 | void AnalogLowPass::design (int numPoles,
 53 |                             double stopBandDb)
 54 | {
 55 |   if (m_numPoles != numPoles ||
 56 |       m_stopBandDb != stopBandDb)
 57 |   {
 58 |     m_numPoles = numPoles;
 59 |     m_stopBandDb = stopBandDb;
 60 | 
 61 |     reset ();
 62 | 
 63 |     const double eps = std::sqrt (1. / (std::exp (stopBandDb * 0.1 * doubleLn10) - 1));
 64 |     const double v0 = asinh (1 / eps) / numPoles;
 65 |     const double sinh_v0 = -sinh (v0);
 66 |     const double cosh_v0 = cosh (v0);
 67 |     const double fn = doublePi / (2 * numPoles);
 68 | 
 69 |     int k = 1;
 70 |     for (int i = numPoles / 2; --i >= 0; k+=2)
 71 |     {
 72 |       const double a = sinh_v0 * cos ((k - numPoles) * fn);
 73 |       const double b = cosh_v0 * sin ((k - numPoles) * fn);
 74 |       const double d2 = a * a + b * b;
 75 |       const double im = 1 / cos (k * fn);
 76 |       addPoleZeroConjugatePairs (complex_t (a / d2, b / d2),
 77 |                                        complex_t (0, im));
 78 |     }
 79 | 
 80 |     if (numPoles & 1)
 81 |     {
 82 |       add (1 / sinh_v0, infinity());
 83 |     }
 84 |   }
 85 | }
 86 | 
 87 | //------------------------------------------------------------------------------
 88 | 
 89 | //
 90 | // Chebyshev Type I low pass shelf prototype
 91 | // From "High-Order Digital Parametric Equalizer Design"
 92 | // Sophocles J. Orfanidis
 93 | // http://www.ece.rutgers.edu/~orfanidi/ece521/hpeq.pdf
 94 | //
 95 | 
 96 | AnalogLowShelf::AnalogLowShelf ()
 97 |   : m_numPoles (-1)
 98 | {
 99 |   setNormal (doublePi, 1);
100 | }
101 | 
102 | void AnalogLowShelf::design (int numPoles,
103 |                              double gainDb,
104 |                              double stopBandDb)
105 | {
106 |   if (m_numPoles != numPoles ||
107 |       m_stopBandDb != stopBandDb ||
108 |       m_gainDb != gainDb)
109 |   {
110 |     m_numPoles = numPoles;
111 |     m_stopBandDb = stopBandDb;
112 |     m_gainDb = gainDb;
113 | 
114 |     reset ();
115 | 
116 |     gainDb = -gainDb;
117 | 
118 |     if (stopBandDb >= fabs(gainDb))
119 |       stopBandDb = fabs (gainDb);
120 |     if (gainDb<0)
121 |       stopBandDb = -stopBandDb;
122 | 
123 |     const double G  = std::pow (10., gainDb / 20.0 );
124 |     const double Gb = std::pow (10., (gainDb - stopBandDb) / 20.0);
125 |     const double G0 = 1;
126 |     const double g0 = pow (G0 , 1. / numPoles);
127 | 
128 |     double eps;
129 |     if (Gb != G0 )
130 |       eps = sqrt((G*G-Gb*Gb)/(Gb*Gb-G0*G0));
131 |     else
132 |       eps = G-1; // This is surely wrong
133 | 
134 |     const double b = pow (G/eps+Gb*sqrt(1+1/(eps*eps)), 1./numPoles);
135 |     const double u = log (b / g0);
136 |     const double v = log (pow (1. / eps+sqrt(1+1/(eps*eps)),1./numPoles));
137 |     
138 |     const double sinh_u = sinh (u);
139 |     const double sinh_v = sinh (v);
140 |     const double cosh_u = cosh (u);
141 |     const double cosh_v = cosh (v);
142 |     const double n2 = 2 * numPoles;
143 |     const int pairs = numPoles / 2;
144 |     for (int i = 1; i <= pairs; ++i)
145 |     {
146 |       const double a = doublePi * (2 * i - 1) / n2;
147 |       const double sn = sin (a);
148 |       const double cs = cos (a);
149 |       addPoleZeroConjugatePairs (complex_t (-sn * sinh_u, cs * cosh_u),
150 |                                        complex_t (-sn * sinh_v, cs * cosh_v));
151 |     }
152 | 
153 |     if (numPoles & 1)
154 |       add (-sinh_u, -sinh_v);
155 |   }
156 | }
157 | 
158 | //------------------------------------------------------------------------------
159 | 
160 | void LowPassBase::setup (int order,
161 |                          double sampleRate,
162 |                          double cutoffFrequency,
163 |                          double stopBandDb)
164 | {
165 |   m_analogProto.design (order, stopBandDb);
166 | 
167 |   LowPassTransform (cutoffFrequency / sampleRate,
168 |                     m_digitalProto,
169 |                     m_analogProto);
170 | 
171 |   Cascade::setLayout (m_digitalProto);
172 | }
173 | 
174 | void HighPassBase::setup (int order,
175 |                           double sampleRate,
176 |                           double cutoffFrequency,
177 |                           double stopBandDb)
178 | {
179 |   m_analogProto.design (order, stopBandDb);
180 | 
181 |   HighPassTransform (cutoffFrequency / sampleRate,
182 |                      m_digitalProto,
183 |                      m_analogProto);
184 | 
185 |   Cascade::setLayout (m_digitalProto);
186 | }
187 | 
188 | void BandPassBase::setup (int order,
189 |                           double sampleRate,
190 |                           double centerFrequency,
191 |                           double widthFrequency,
192 |                           double stopBandDb)
193 | {
194 |   m_analogProto.design (order, stopBandDb);
195 | 
196 |   BandPassTransform (centerFrequency / sampleRate,
197 |                      widthFrequency / sampleRate,
198 |                      m_digitalProto,
199 |                      m_analogProto);
200 | 
201 |   Cascade::setLayout (m_digitalProto);
202 | }
203 | 
204 | void BandStopBase::setup (int order,
205 |                           double sampleRate,
206 |                           double centerFrequency,
207 |                           double widthFrequency,
208 |                           double stopBandDb)
209 | {
210 |   m_analogProto.design (order, stopBandDb);
211 | 
212 |   BandStopTransform (centerFrequency / sampleRate,
213 |                      widthFrequency / sampleRate,
214 |                      m_digitalProto,
215 |                      m_analogProto);
216 | 
217 |   Cascade::setLayout (m_digitalProto);
218 | }
219 | 
220 | void LowShelfBase::setup (int order,
221 |                           double sampleRate,
222 |                           double cutoffFrequency,
223 |                           double gainDb,
224 |                           double stopBandDb)
225 | {
226 |   m_analogProto.design (order, gainDb, stopBandDb);
227 | 
228 |   LowPassTransform (cutoffFrequency / sampleRate,
229 |                     m_digitalProto,
230 |                     m_analogProto);
231 | 
232 |   Cascade::setLayout (m_digitalProto);
233 | }
234 | 
235 | void HighShelfBase::setup (int order,
236 |                            double sampleRate,
237 |                            double cutoffFrequency,
238 |                            double gainDb,
239 |                            double stopBandDb)
240 | {
241 |   m_analogProto.design (order, gainDb, stopBandDb);
242 | 
243 |   HighPassTransform (cutoffFrequency / sampleRate,
244 |                      m_digitalProto,
245 |                      m_analogProto);
246 | 
247 |   Cascade::setLayout (m_digitalProto);
248 | }
249 | 
250 | void BandShelfBase::setup (int order,
251 |                            double sampleRate,
252 |                            double centerFrequency,
253 |                            double widthFrequency,
254 |                            double gainDb,
255 |                            double stopBandDb)
256 | {
257 |   m_analogProto.design (order, gainDb, stopBandDb);
258 | 
259 |   BandPassTransform (centerFrequency / sampleRate,
260 |                      widthFrequency / sampleRate,
261 |                      m_digitalProto,
262 |                      m_analogProto);
263 | 
264 |   m_digitalProto.setNormal (((centerFrequency/sampleRate) < 0.25) ? doublePi : 0, 1);
265 | 
266 |   Cascade::setLayout (m_digitalProto);
267 | }
268 | 
269 | }
270 | 
271 | }
272 | 


--------------------------------------------------------------------------------
/src/DspFilters/Common.h:
--------------------------------------------------------------------------------
 1 | /*******************************************************************************
 2 | 
 3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
 4 |  By Vinnie Falco
 5 | 
 6 | Official project location:
 7 | https://github.com/vinniefalco/DSPFilters
 8 | 
 9 | See Documentation.cpp for contact information, notes, and bibliography.
10 | 
11 | --------------------------------------------------------------------------------
12 | 
13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
14 | Copyright (c) 2009 by Vinnie Falco
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy
17 | of this software and associated documentation files (the "Software"), to deal
18 | in the Software without restriction, including without limitation the rights
19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
20 | copies of the Software, and to permit persons to whom the Software is
21 | furnished to do so, subject to the following conditions:
22 | 
23 | The above copyright notice and this permission notice shall be included in
24 | all copies or substantial portions of the Software.
25 | 
26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
32 | THE SOFTWARE.
33 | 
34 | *******************************************************************************/
35 | 
36 | #ifndef DSPFILTERS_COMMON_H
37 | #define DSPFILTERS_COMMON_H
38 | 
39 | //
40 | // This must be the first file included in every DspFilters header and source
41 | //
42 | 
43 | #ifdef _MSC_VER
44 | #  pragma warning (disable: 4100)
45 | #endif
46 | 
47 | //#include <assert.h>
48 | #include <stdlib.h>
49 | 
50 | #include <cassert>
51 | #include <cfloat>
52 | #include <cmath>
53 | #include <complex>
54 | #include <cstring>
55 | #include <string>
56 | #include <limits>
57 | #include <vector>
58 | 
59 | #ifdef _MSC_VER
60 | namespace tr1 = std::tr1;
61 | #else
62 | namespace tr1 = std;
63 | #endif
64 | 
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/src/DspFilters/Custom.cpp:
--------------------------------------------------------------------------------
 1 | /*******************************************************************************
 2 | 
 3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
 4 |  By Vinnie Falco
 5 | 
 6 | Official project location:
 7 | https://github.com/vinniefalco/DSPFilters
 8 | 
 9 | See Documentation.cpp for contact information, notes, and bibliography.
10 | 
11 | --------------------------------------------------------------------------------
12 | 
13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
14 | Copyright (c) 2009 by Vinnie Falco
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy
17 | of this software and associated documentation files (the "Software"), to deal
18 | in the Software without restriction, including without limitation the rights
19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
20 | copies of the Software, and to permit persons to whom the Software is
21 | furnished to do so, subject to the following conditions:
22 | 
23 | The above copyright notice and this permission notice shall be included in
24 | all copies or substantial portions of the Software.
25 | 
26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
32 | THE SOFTWARE.
33 | 
34 | *******************************************************************************/
35 | 
36 | #include "DspFilters/Common.h"
37 | #include "DspFilters/Custom.h"
38 | 
39 | namespace Dsp {
40 | 
41 | namespace Custom {
42 | 
43 | void OnePole::setup (double scale,
44 |                      double pole,
45 |                      double zero)
46 | {
47 |   setOnePole (pole, zero);
48 |   applyScale (scale);
49 | }
50 | 
51 | void TwoPole::setup (double scale,
52 |                      double poleRho,
53 |                      double poleTheta,
54 |                      double zeroRho,
55 |                      double zeroTheta)
56 | {
57 |   complex_t pole = std::polar (poleRho, poleTheta);
58 |   complex_t zero = std::polar (zeroRho, zeroTheta);
59 | 
60 |   setTwoPole (pole, zero, std::conj(pole), std::conj(zero));
61 |   applyScale (scale);
62 | }
63 | 
64 | }
65 | 
66 | }
67 | 


--------------------------------------------------------------------------------
/src/DspFilters/Custom.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_CUSTOM_H
 37 | #define DSPFILTERS_CUSTOM_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Biquad.h"
 41 | #include "DspFilters/Design.h"
 42 | #include "DspFilters/Filter.h"
 43 | 
 44 | namespace Dsp {
 45 | 
 46 | /*
 47 |  * Single pole and Biquad with parameters allowing
 48 |  * for directly setting the poles and zeros
 49 |  *
 50 |  */
 51 | 
 52 | namespace Custom {
 53 | 
 54 | //
 55 | // Raw filters
 56 | //
 57 | 
 58 | struct OnePole : Biquad
 59 | {
 60 |   void setup (double scale,
 61 |               double pole,
 62 |               double zero);
 63 | };
 64 | 
 65 | struct TwoPole : Biquad
 66 | {
 67 |   void setup (double scale,
 68 |               double poleRho,
 69 |               double poleTheta,
 70 |               double zeroRho,
 71 |               double zeroTheta);
 72 | };
 73 | 
 74 | //------------------------------------------------------------------------------
 75 | 
 76 | //
 77 | // Gui-friendly Design layer
 78 | //
 79 | 
 80 | namespace Design {
 81 | 
 82 | struct OnePole : DesignBase, Custom::OnePole
 83 | {
 84 |   enum
 85 |   {
 86 |     NumParams = 4
 87 |   };
 88 | 
 89 |   static int getNumParams ()
 90 |   {
 91 |     return 4;
 92 |   }
 93 | 
 94 |   static const ParamInfo getParamInfo_1 ()
 95 |   {
 96 |     return ParamInfo::defaultGainParam ();
 97 |   }
 98 | 
 99 |   static const ParamInfo getParamInfo_2 ()
100 |   {
101 |     return ParamInfo::defaultPoleRealParam ();
102 |   }
103 | 
104 |   static const ParamInfo getParamInfo_3 ()
105 |   {
106 |     return ParamInfo::defaultZeroRealParam ();
107 |   }
108 | 
109 |   static Kind getKind () { return kindOther; }
110 |   static const char* getName() { return "Custom One-Pole"; }
111 | 
112 |   void setParams (const Params& params)
113 |   {
114 |     setup (pow (10., params[1]/20),
115 |            params[2],
116 |            params[3]);
117 |   }
118 | };
119 | 
120 | struct TwoPole : DesignBase, Custom::TwoPole
121 | {
122 |   enum
123 |   {
124 |     NumParams = 6
125 |   };
126 | 
127 |   static int getNumParams ()
128 |   {
129 |     return 6;
130 |   }
131 | 
132 |   static const ParamInfo getParamInfo_1 ()
133 |   {
134 |     return ParamInfo::defaultGainParam ();
135 |   }
136 | 
137 |   static const ParamInfo getParamInfo_2 ()
138 |   {
139 |     return ParamInfo::defaultPoleRhoParam ();
140 |   }
141 | 
142 |   static const ParamInfo getParamInfo_3 ()
143 |   {
144 |     return ParamInfo::defaultPoleThetaParam ();
145 |   }
146 | 
147 |   static const ParamInfo getParamInfo_4 ()
148 |   {
149 |     return ParamInfo::defaultZeroRhoParam ();
150 |   }
151 | 
152 |   static const ParamInfo getParamInfo_5 ()
153 |   {
154 |     return ParamInfo::defaultZeroThetaParam ();
155 |   }
156 | 
157 | 
158 |   static Kind getKind () { return kindOther; }
159 |   static const char* getName() { return "Custom Two-Pole"; }
160 | 
161 |   void setParams (const Params& params)
162 |   {
163 |     setup (pow (10., params[1]/20),
164 |            params[2],
165 |            params[3],
166 |            params[4],
167 |            params[5]);
168 |   }
169 | };
170 | 
171 | }
172 | 
173 | }
174 | 
175 | }
176 | 
177 | #endif
178 | 


--------------------------------------------------------------------------------
/src/DspFilters/Design.cpp:
--------------------------------------------------------------------------------
 1 | /*******************************************************************************
 2 | 
 3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
 4 |  By Vinnie Falco
 5 | 
 6 | Official project location:
 7 | https://github.com/vinniefalco/DSPFilters
 8 | 
 9 | See Documentation.cpp for contact information, notes, and bibliography.
10 | 
11 | --------------------------------------------------------------------------------
12 | 
13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
14 | Copyright (c) 2009 by Vinnie Falco
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy
17 | of this software and associated documentation files (the "Software"), to deal
18 | in the Software without restriction, including without limitation the rights
19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
20 | copies of the Software, and to permit persons to whom the Software is
21 | furnished to do so, subject to the following conditions:
22 | 
23 | The above copyright notice and this permission notice shall be included in
24 | all copies or substantial portions of the Software.
25 | 
26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
32 | THE SOFTWARE.
33 | 
34 | *******************************************************************************/
35 | 
36 | #include "DspFilters/Common.h"
37 | #include "DspFilters/Design.h"
38 | 
39 | namespace Dsp {
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/src/DspFilters/Design.h:
--------------------------------------------------------------------------------
 1 | /*******************************************************************************
 2 | 
 3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
 4 |  By Vinnie Falco
 5 | 
 6 | Official project location:
 7 | https://github.com/vinniefalco/DSPFilters
 8 | 
 9 | See Documentation.cpp for contact information, notes, and bibliography.
10 | 
11 | --------------------------------------------------------------------------------
12 | 
13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
14 | Copyright (c) 2009 by Vinnie Falco
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy
17 | of this software and associated documentation files (the "Software"), to deal
18 | in the Software without restriction, including without limitation the rights
19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
20 | copies of the Software, and to permit persons to whom the Software is
21 | furnished to do so, subject to the following conditions:
22 | 
23 | The above copyright notice and this permission notice shall be included in
24 | all copies or substantial portions of the Software.
25 | 
26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
32 | THE SOFTWARE.
33 | 
34 | *******************************************************************************/
35 | 
36 | #ifndef DSPFILTERS_DESIGN_H
37 | #define DSPFILTERS_DESIGN_H
38 | 
39 | #include "DspFilters/Common.h"
40 | #include "DspFilters/Params.h"
41 | 
42 | namespace Dsp {
43 | 
44 | struct DesignBase
45 | {
46 |   // Sampling rate is the first param for every Design filter
47 |   static const ParamInfo getParamInfo_0 ()
48 |   {
49 |     return ParamInfo::defaultSampleRateParam ();
50 |   }
51 | 
52 |   // These should never get called
53 |   static const ParamInfo getParamInfo_1 () { return ParamInfo(); }
54 |   static const ParamInfo getParamInfo_2 () { return ParamInfo(); }
55 |   static const ParamInfo getParamInfo_3 () { return ParamInfo(); }
56 |   static const ParamInfo getParamInfo_4 () { return ParamInfo(); }
57 |   static const ParamInfo getParamInfo_5 () { return ParamInfo(); }
58 |   static const ParamInfo getParamInfo_6 () { return ParamInfo(); }
59 |   static const ParamInfo getParamInfo_7 () { return ParamInfo(); }
60 | };
61 | 
62 | }
63 | 
64 | #endif
65 | 


--------------------------------------------------------------------------------
/src/DspFilters/Dsp.h:
--------------------------------------------------------------------------------
 1 | /*******************************************************************************
 2 | 
 3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
 4 |  By Vinnie Falco
 5 | 
 6 | Official project location:
 7 | https://github.com/vinniefalco/DSPFilters
 8 | 
 9 | See Documentation.cpp for contact information, notes, and bibliography.
10 | 
11 | --------------------------------------------------------------------------------
12 | 
13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
14 | Copyright (c) 2009 by Vinnie Falco
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy
17 | of this software and associated documentation files (the "Software"), to deal
18 | in the Software without restriction, including without limitation the rights
19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
20 | copies of the Software, and to permit persons to whom the Software is
21 | furnished to do so, subject to the following conditions:
22 | 
23 | The above copyright notice and this permission notice shall be included in
24 | all copies or substantial portions of the Software.
25 | 
26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
32 | THE SOFTWARE.
33 | 
34 | *******************************************************************************/
35 | 
36 | #ifndef DSPFILTERS_DSP_H
37 | #define DSPFILTERS_DSP_H
38 | 
39 | //
40 | // Include this file in your application to get everything
41 | //
42 | 
43 | #include "DspFilters/Common.h"
44 | 
45 | #include "DspFilters/Biquad.h"
46 | #include "DspFilters/Cascade.h"
47 | #include "DspFilters/Filter.h"
48 | #include "DspFilters/PoleFilter.h"
49 | #include "DspFilters/SmoothedFilter.h"
50 | #include "DspFilters/State.h"
51 | #include "DspFilters/Utilities.h"
52 | 
53 | #include "DspFilters/Bessel.h"
54 | #include "DspFilters/Butterworth.h"
55 | #include "DspFilters/ChebyshevI.h"
56 | #include "DspFilters/ChebyshevII.h"
57 | #include "DspFilters/Custom.h"
58 | #include "DspFilters/Elliptic.h"
59 | #include "DspFilters/Legendre.h"
60 | #include "DspFilters/RBJ.h"
61 | 
62 | #endif
63 | 


--------------------------------------------------------------------------------
/src/DspFilters/Elliptic.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_ELLIPTIC_H
 37 | #define DSPFILTERS_ELLIPTIC_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Cascade.h"
 41 | #include "DspFilters/Design.h"
 42 | #include "DspFilters/Filter.h"
 43 | #include "DspFilters/PoleFilter.h"
 44 | 
 45 | namespace Dsp {
 46 | 
 47 | /*
 48 |  * Filters with Elliptic response characteristics
 49 |  *
 50 |  */
 51 | 
 52 | namespace Elliptic {
 53 | 
 54 | // Solves for Jacobi elliptics
 55 | class Solver
 56 | {
 57 | public:
 58 |   static double ellipticK (double k);
 59 | };
 60 | 
 61 | // Half-band analog prototype (s-plane)
 62 | 
 63 | class AnalogLowPass : public LayoutBase
 64 | {
 65 | public:
 66 |   AnalogLowPass ();
 67 | 
 68 |   void design (const int numPoles,
 69 |                double rippleDb,
 70 |                double rolloff);
 71 | 
 72 | private:
 73 |   void prodpoly    (int sn);
 74 |   void calcfz2     (int i);
 75 |   void calcfz      ();
 76 |   void calcqz      ();
 77 |   double findfact	 (int t);
 78 |   double calcsn		 (double u);
 79 | 
 80 | #if 0
 81 |   template<int n>
 82 |   struct CalcArray
 83 |   {
 84 |     double& operator[](size_t index)
 85 |     {
 86 |       assert( index<n );
 87 |       return m_a[index];
 88 |     }
 89 |   private:
 90 |     double m_a[n];
 91 |   };
 92 | #else
 93 | #endif
 94 | 
 95 |   double m_p0;
 96 |   double m_q;
 97 |   double m_K;
 98 |   double m_Kprime;
 99 |   double m_e;
100 |   int m_nin;
101 |   int m_m;
102 |   int m_n2;
103 |   int m_em;
104 |   double m_zeros[100];
105 |   double m_c1[100];
106 |   double m_b1[100];
107 |   double m_a1[100];
108 |   double m_d1[100];
109 |   double m_q1[100];
110 |   double m_z1[100];
111 |   double m_f1[100];
112 |   double m_s1[100];
113 |   double m_p [100];
114 |   double m_zw1[100];
115 |   double m_zf1[100];
116 |   double m_zq1[100];
117 |   double m_rootR[100];
118 |   double m_rootI[100];
119 | 
120 |   int m_numPoles;
121 |   double m_rippleDb;
122 |   double m_rolloff;
123 | };
124 | 
125 | //------------------------------------------------------------------------------
126 | 
127 | // Factored implementations to reduce template instantiations
128 | 
129 | struct LowPassBase : PoleFilterBase <AnalogLowPass>
130 | {
131 |   void setup (int order,
132 |               double sampleRate,
133 |               double cutoffFrequency,
134 |               double rippleDb,
135 |               double rolloff);
136 | };
137 | 
138 | struct HighPassBase : PoleFilterBase <AnalogLowPass>
139 | {
140 |   void setup (int order,
141 |               double sampleRate,
142 |               double cutoffFrequency,
143 |               double rippleDb,
144 |               double rolloff);
145 | };
146 | 
147 | struct BandPassBase : PoleFilterBase <AnalogLowPass>
148 | {
149 |   void setup (int order,
150 |               double sampleRate,
151 |               double centerFrequency,
152 |               double widthFrequency,
153 |               double rippleDb,
154 |               double rolloff);
155 | };
156 | 
157 | struct BandStopBase : PoleFilterBase <AnalogLowPass>
158 | {
159 |   void setup (int order,
160 |               double sampleRate,
161 |               double centerFrequency,
162 |               double widthFrequency,
163 |               double rippleDb,
164 |               double rolloff);
165 | };
166 | 
167 | //------------------------------------------------------------------------------
168 | 
169 | //
170 | // Raw filters
171 | //
172 | 
173 | template <int MaxOrder>
174 | struct LowPass : PoleFilter <LowPassBase, MaxOrder>
175 | {
176 | };
177 | 
178 | template <int MaxOrder>
179 | struct HighPass : PoleFilter <HighPassBase, MaxOrder>
180 | {
181 | };
182 | 
183 | template <int MaxOrder>
184 | struct BandPass : PoleFilter <BandPassBase, MaxOrder, MaxOrder*2>
185 | {
186 | };
187 | 
188 | template <int MaxOrder>
189 | struct BandStop : PoleFilter <BandStopBase, MaxOrder, MaxOrder*2>
190 | {
191 | };
192 | 
193 | //------------------------------------------------------------------------------
194 | 
195 | //
196 | // Gui-friendly Design layer
197 | //
198 | 
199 | namespace Design {
200 | 
201 | struct TypeIBase : DesignBase
202 | {
203 |   enum
204 |   {
205 |     NumParams = 5
206 |   };
207 | 
208 |   static int getNumParams ()
209 |   {
210 |     return 5;
211 |   }
212 | 
213 |   static const ParamInfo getParamInfo_2 ()
214 |   {
215 |     return ParamInfo::defaultCutoffFrequencyParam ();
216 |   }
217 | 
218 |   static const ParamInfo getParamInfo_3 ()
219 |   {
220 |     return ParamInfo::defaultRippleDbParam ();
221 |   }
222 | 
223 |   static const ParamInfo getParamInfo_4 ()
224 |   {
225 |     return ParamInfo::defaultRolloffParam ();
226 |   }
227 | };
228 | 
229 | template <class FilterClass>
230 | struct TypeI : TypeIBase, FilterClass
231 | {
232 |   void setParams (const Params& params)
233 |   {
234 |     FilterClass::setup (int(params[1]), params[0], params[2], params[3], params[4]);
235 |   }
236 | };
237 | 
238 | struct TypeIIBase : DesignBase
239 | {
240 |   enum
241 |   {
242 |     NumParams = 6
243 |   };
244 | 
245 |   static int getNumParams ()
246 |   {
247 |     return 6;
248 |   }
249 | 
250 |   static const ParamInfo getParamInfo_2 ()
251 |   {
252 |     return ParamInfo::defaultCenterFrequencyParam ();
253 |   }
254 | 
255 |   static const ParamInfo getParamInfo_3 ()
256 |   {
257 |     return ParamInfo::defaultBandwidthHzParam ();
258 |   }
259 | 
260 |   static const ParamInfo getParamInfo_4 ()
261 |   {
262 |     return ParamInfo::defaultRippleDbParam ();
263 |   }
264 | 
265 |   static const ParamInfo getParamInfo_5 ()
266 |   {
267 |     return ParamInfo::defaultRolloffParam ();
268 |   }
269 | };
270 | 
271 | template <class FilterClass>
272 | struct TypeII : TypeIIBase, FilterClass
273 | {
274 |   void setParams (const Params& params)
275 |   {
276 |     FilterClass::setup (int(params[1]), params[0], params[2], params[3], params[4], params[5]);
277 |   }
278 | };
279 | 
280 | // Factored kind and name
281 | 
282 | struct LowPassDescription
283 | {
284 |   static Kind getKind () { return kindLowPass; }
285 |   static const char* getName() { return "Elliptic Low Pass"; }
286 | };
287 | 
288 | struct HighPassDescription
289 | {
290 |   static Kind getKind () { return kindHighPass; }
291 |   static const char* getName() { return "Elliptic High Pass"; }
292 | };
293 | 
294 | struct BandPassDescription
295 | {
296 |   static Kind getKind () { return kindHighPass; }
297 |   static const char* getName() { return "Elliptic Band Pass"; }
298 | };
299 | 
300 | struct BandStopDescription
301 | {
302 |   static Kind getKind () { return kindHighPass; }
303 |   static const char* getName() { return "Elliptic Band Stop"; }
304 | };
305 | 
306 | // This glues on the Order parameter
307 | template <int MaxOrder,
308 |           template <class> class TypeClass,
309 |           template <int> class FilterClass>
310 | struct OrderBase : TypeClass <FilterClass <MaxOrder> >
311 | {
312 |   const ParamInfo getParamInfo_1 () const
313 |   {
314 |     return ParamInfo (idOrder, "Order", "Order",
315 |                        1, MaxOrder, 2,
316 |                        &ParamInfo::Int_toControlValue,
317 |                        &ParamInfo::Int_toNativeValue,
318 |                        &ParamInfo::Int_toString);
319 | 
320 |   }
321 | };
322 | //------------------------------------------------------------------------------
323 | 
324 | //
325 | // Design filters
326 | //
327 | 
328 | template <int MaxOrder>
329 | struct LowPass : OrderBase <MaxOrder, TypeI, Elliptic::LowPass>,
330 |                  LowPassDescription
331 | {
332 | };
333 | 
334 | template <int MaxOrder>
335 | struct HighPass : OrderBase <MaxOrder, TypeI, Elliptic::HighPass>,
336 |                   HighPassDescription
337 | {
338 | };
339 | 
340 | template <int MaxOrder>
341 | struct BandPass : OrderBase <MaxOrder, TypeII, Elliptic::BandPass>,
342 |                   BandPassDescription
343 | {
344 | };
345 | 
346 | template <int MaxOrder>
347 | struct BandStop : OrderBase <MaxOrder, TypeII, Elliptic::BandStop>,
348 |                   BandStopDescription
349 | {
350 | };
351 | 
352 | }
353 | 
354 | }
355 | 
356 | }
357 | 
358 | #endif
359 | 
360 | 


--------------------------------------------------------------------------------
/src/DspFilters/Filter.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/Filter.h"
 38 | 
 39 | namespace Dsp {
 40 | 
 41 | Params Filter::getDefaultParams() const
 42 | {
 43 |   Params params;
 44 | 
 45 |   params.clear();
 46 | 
 47 |   for (int i = 0; i < getNumParams(); ++i)
 48 |     params[i] = getParamInfo(i).getDefaultValue();
 49 | 
 50 |   return params;
 51 | }
 52 | 
 53 | Filter::~Filter()
 54 | {
 55 | }
 56 | 
 57 | int Filter::findParamId (int paramId)
 58 | {
 59 |   int index = -1;
 60 | 
 61 |   for (int i = getNumParams(); --i >= 0;)
 62 |   {
 63 |     if (getParamInfo (i).getId () == paramId)
 64 |     {
 65 |       index = i;
 66 |       break;
 67 |     }
 68 |   }
 69 | 
 70 |   return index;
 71 | }
 72 | 
 73 | void Filter::setParamById (int paramId, double nativeValue)
 74 | {
 75 |   for (int i = getNumParams(); --i >= 0;)
 76 |   {
 77 |     if (getParamInfo (i).getId () == paramId)
 78 |     {
 79 |       setParam (i, nativeValue);
 80 |       return;
 81 |     }
 82 |   }
 83 |   
 84 |   assert (0);
 85 | }
 86 | 
 87 | void Filter::copyParamsFrom (Dsp::Filter const* other)
 88 | {
 89 |   // first, set reasonable defaults
 90 |   m_params = getDefaultParams ();
 91 | 
 92 |   if (other)
 93 |   {
 94 |     // now loop
 95 |     for (int i = 0; i < getNumParams (); ++i)
 96 |     {
 97 |       const ParamInfo& paramInfo = getParamInfo (i);
 98 | 
 99 |       // find a match
100 |       for (int j = 0; j < other->getNumParams(); ++j)
101 |       {
102 |         const ParamInfo& otherParamInfo = other->getParamInfo (j);
103 | 
104 |         if (paramInfo.getId() == otherParamInfo.getId())
105 |         {
106 |           // match!
107 |           m_params [i] = paramInfo.clamp (other->getParam (j));
108 |           break;
109 |         }
110 |       }
111 |     }
112 |   }
113 | 
114 |   doSetParams (m_params);
115 | }
116 | 
117 | }
118 | 


--------------------------------------------------------------------------------
/src/DspFilters/Filter.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_FILTER_H
 37 | #define DSPFILTERS_FILTER_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/MathSupplement.h"
 41 | #include "DspFilters/Params.h"
 42 | #include "DspFilters/State.h"
 43 | #include "DspFilters/Types.h"
 44 | 
 45 | namespace Dsp {
 46 | 
 47 | /*
 48 |  * Filter
 49 |  *
 50 |  * Full abstraction of a digital IIR filter.
 51 |  * Supports run-time introspection and modulation of filter
 52 |  * parameters.
 53 |  *
 54 |  */
 55 | class Filter
 56 | {
 57 | public:
 58 |   virtual ~Filter();
 59 | 
 60 |   virtual Kind getKind () const = 0;
 61 | 
 62 |   virtual const std::string getName () const = 0;
 63 | 
 64 |   virtual int getNumParams () const = 0;  
 65 | 
 66 |   virtual ParamInfo getParamInfo (int index) const = 0;
 67 | 
 68 |   Params getDefaultParams() const;
 69 | 
 70 |   const Params& getParams() const
 71 |   {
 72 |     return m_params;
 73 |   }
 74 | 
 75 |   double getParam (int paramIndex) const
 76 |   {
 77 |     assert (paramIndex >= 0 && paramIndex <= getNumParams());
 78 |     return m_params[paramIndex];
 79 |   }
 80 | 
 81 |   void setParam (int paramIndex, double nativeValue)
 82 |   {
 83 |     assert (paramIndex >= 0 && paramIndex <= getNumParams());
 84 |     m_params[paramIndex] = nativeValue;
 85 |     doSetParams (m_params);
 86 |   }
 87 | 
 88 |   int findParamId (int paramId);
 89 | 
 90 |   void setParamById (int paramId, double nativeValue);
 91 | 
 92 |   void setParams (const Params& parameters)
 93 |   {
 94 |     m_params = parameters;
 95 |     doSetParams (parameters);
 96 |   }
 97 | 
 98 |   // This makes a best-effort to pick up the values
 99 |   // of matching parameters from another set. It uses
100 |   // the ParamID information to make the match.
101 |   void copyParamsFrom (Dsp::Filter const* other);
102 | 
103 |   virtual std::vector<PoleZeroPair> getPoleZeros() const = 0;
104 |  
105 |   virtual complex_t response (double normalizedFrequency) const = 0;
106 | 
107 |   virtual int getNumChannels() = 0;
108 |   virtual void reset () = 0;
109 |   virtual void process (int numSamples, float* const* arrayOfChannels) = 0;
110 |   virtual void process (int numSamples, double* const* arrayOfChannels) = 0;
111 | 
112 | protected:
113 |   virtual void doSetParams (const Params& parameters) = 0;
114 | 
115 | private:
116 |   Params m_params;
117 | };
118 | 
119 | //------------------------------------------------------------------------------
120 | 
121 | /*
122 |  * FilterDesign
123 |  *
124 |  * This container holds a filter Design (Gui-friendly layer) and
125 |  * optionally combines it with the necessary state information to
126 |  * process channel data.
127 |  *
128 |  */
129 | 
130 | // Factored to reduce template instantiations
131 | template <class DesignClass>
132 | class FilterDesignBase : public Filter
133 | {
134 | public:
135 |   Kind getKind () const
136 |   {
137 |     return m_design.getKind ();
138 |   }
139 | 
140 |   const std::string getName () const
141 |   {
142 |     return m_design.getName ();
143 |   }
144 | 
145 |   int getNumParams () const
146 |   {
147 |     return DesignClass::NumParams;
148 |   }
149 | 
150 |   Params getDefaultParams() const
151 |   {
152 |     return m_design.getDefaultParams();
153 |   }
154 | 
155 |   ParamInfo getParamInfo (int index) const
156 |   {
157 |     switch (index)
158 |     {
159 |     case 0: return m_design.getParamInfo_0 ();
160 |     case 1: return m_design.getParamInfo_1 ();
161 |     case 2: return m_design.getParamInfo_2 ();
162 |     case 3: return m_design.getParamInfo_3 ();
163 |     case 4: return m_design.getParamInfo_4 ();
164 |     case 5: return m_design.getParamInfo_5 ();
165 |     case 6: return m_design.getParamInfo_6 ();
166 |     case 7: return m_design.getParamInfo_7 ();
167 |     };
168 | 
169 |     return ParamInfo();
170 |   }
171 | 
172 |   std::vector<PoleZeroPair> getPoleZeros() const
173 |   {
174 |     return m_design.getPoleZeros();
175 |   }
176 |  
177 |   complex_t response (double normalizedFrequency) const
178 |   {
179 |     return m_design.response (normalizedFrequency);
180 |   }
181 | 
182 | protected:
183 |   void doSetParams (const Params& parameters)
184 |   {
185 |     m_design.setParams (parameters);
186 |   }
187 | 
188 | protected:
189 |   DesignClass m_design;
190 | };
191 | 
192 | 
193 | 
194 | template <class DesignClass,
195 |           int Channels = 0,
196 |           class StateType = DirectFormII>
197 | class FilterDesign : public FilterDesignBase <DesignClass>
198 | {
199 | public:
200 |   FilterDesign ()
201 |   {
202 |   }
203 | 
204 |   int getNumChannels()
205 |   {
206 |     return Channels;
207 |   }
208 | 
209 |   void reset ()
210 |   {
211 |     m_state.reset();
212 |   }
213 | 
214 |   void process (int numSamples, float* const* arrayOfChannels)
215 |   {
216 |     m_state.process (numSamples, arrayOfChannels,
217 |                      FilterDesignBase<DesignClass>::m_design);
218 |   }
219 | 
220 |   void process (int numSamples, double* const* arrayOfChannels)
221 |   {
222 |     m_state.process (numSamples, arrayOfChannels,
223 |                      FilterDesignBase<DesignClass>::m_design);
224 |   }
225 | 
226 | protected:
227 |   ChannelsState <Channels,
228 |                  typename DesignClass::template State <StateType> > m_state;
229 | };
230 | 
231 | //------------------------------------------------------------------------------
232 | 
233 | /*
234 |  * This container combines a raw filter with state information
235 |  * so it can process channels. In order to set up the filter you
236 |  * must call a setup function directly. Smooth changes are
237 |  * not supported, but this class has a smaller footprint.
238 |  *
239 |  */
240 | template <class FilterClass,
241 |           int Channels = 0,
242 |           class StateType = DirectFormII>
243 | class SimpleFilter : public FilterClass
244 | {
245 | public:
246 |   int getNumChannels()
247 |   {
248 |     return Channels;
249 |   }
250 | 
251 |   void reset ()
252 |   {
253 |     m_state.reset();
254 |   }
255 | 
256 |   template <typename Sample>
257 |   void process (int numSamples, Sample* const* arrayOfChannels)
258 |   {
259 |     m_state.process (numSamples, arrayOfChannels, *((FilterClass*)this));
260 |   }
261 | 
262 | protected:
263 |   ChannelsState <Channels,
264 |                  typename FilterClass::template State <StateType> > m_state;
265 | };
266 | 
267 | }
268 | 
269 | #endif
270 | 


--------------------------------------------------------------------------------
/src/DspFilters/Layout.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_LAYOUT_H
 37 | #define DSPFILTERS_LAYOUT_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/MathSupplement.h"
 41 | 
 42 | namespace Dsp {
 43 | 
 44 | //
 45 | // Describes a filter as a collection of poles and zeros along with
 46 | // normalization information to achieve a specified gain at a specified
 47 | // frequency. The poles and zeros may lie either in the s or the z plane.
 48 | //
 49 | 
 50 | // Base uses pointers to reduce template instantiations
 51 | class LayoutBase
 52 | {
 53 | public:
 54 |   LayoutBase ()
 55 |     : m_numPoles (0)
 56 |     , m_maxPoles (0)
 57 |   {
 58 |   }
 59 | 
 60 |   LayoutBase (int maxPoles, PoleZeroPair* pairs)
 61 |     : m_numPoles (0)
 62 |     , m_maxPoles (maxPoles)
 63 |     , m_pair (pairs)
 64 |   {
 65 |   }
 66 | 
 67 |   void setStorage (const LayoutBase& other)
 68 |   {
 69 |     m_numPoles = 0;
 70 |     m_maxPoles = other.m_maxPoles;
 71 |     m_pair = other.m_pair;
 72 |   }
 73 | 
 74 |   void reset ()
 75 |   {
 76 |     m_numPoles = 0;
 77 |   }
 78 | 
 79 |   int getNumPoles () const
 80 |   {
 81 |     return m_numPoles;
 82 |   }
 83 | 
 84 |   int getMaxPoles () const
 85 |   {
 86 |     return m_maxPoles;
 87 |   }
 88 | 
 89 |   void add (const complex_t& pole, const complex_t& zero)
 90 |   {
 91 |     assert (!(m_numPoles&1)); // single comes last
 92 |     assert (!Dsp::is_nan (pole));
 93 |     m_pair[m_numPoles/2] = PoleZeroPair (pole, zero);
 94 |     ++m_numPoles;
 95 |   }
 96 | 
 97 |   void addPoleZeroConjugatePairs (const complex_t pole,
 98 |                                   const complex_t zero)
 99 |   {
100 |     assert (!(m_numPoles&1)); // single comes last
101 |     assert (!Dsp::is_nan (pole));
102 |     m_pair[m_numPoles/2] = PoleZeroPair (
103 |       pole, zero, std::conj (pole), std::conj (zero));
104 |     m_numPoles += 2;
105 |   }
106 | 
107 |   void add (const ComplexPair& poles, const ComplexPair& zeros)
108 |   {
109 |     assert (!(m_numPoles&1)); // single comes last
110 |     assert (poles.isMatchedPair ());
111 |     assert (zeros.isMatchedPair ());
112 |     m_pair[m_numPoles/2] = PoleZeroPair (poles.first, zeros.first,
113 |                                          poles.second, zeros.second);
114 |     m_numPoles += 2;
115 |   }
116 | 
117 |   const PoleZeroPair& getPair (int pairIndex) const
118 |   {
119 |     assert (pairIndex >= 0 && pairIndex < (m_numPoles+1)/2);
120 |     return m_pair[pairIndex];
121 |   }
122 | 
123 |   const PoleZeroPair& operator[] (int pairIndex) const
124 |   {
125 |     return getPair (pairIndex);
126 |   }
127 | 
128 |   double getNormalW () const
129 |   {
130 |     return m_normalW;
131 |   }
132 | 
133 |   double getNormalGain () const
134 |   {
135 |     return m_normalGain;
136 |   }
137 | 
138 |   void setNormal (double w, double g)
139 |   {
140 |     m_normalW = w;
141 |     m_normalGain = g;
142 |   }
143 | 
144 | private:
145 |   int m_numPoles;
146 |   int m_maxPoles;
147 |   PoleZeroPair* m_pair;
148 |   double m_normalW;
149 |   double m_normalGain;
150 | };
151 | 
152 | //------------------------------------------------------------------------------
153 | 
154 | // Storage for Layout
155 | template <int MaxPoles>
156 | class Layout
157 | {
158 | public:
159 |   operator LayoutBase ()
160 |   {
161 |     return LayoutBase (MaxPoles, m_pairs);
162 |   }
163 | 
164 | private:
165 |   PoleZeroPair m_pairs[(MaxPoles+1)/2];
166 | };
167 | 
168 | }
169 | 
170 | #endif
171 | 


--------------------------------------------------------------------------------
/src/DspFilters/Legendre.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/Legendre.h"
 38 | #include "DspFilters/RootFinder.h"
 39 | 
 40 | #include <sstream>
 41 | #include <iostream>
 42 | #include <iomanip>
 43 | 
 44 | namespace Dsp {
 45 | 
 46 | namespace Legendre {
 47 | 
 48 | static inline double m_sqrt2 ()
 49 | {
 50 |   return 1.41421356237309504880;
 51 | }
 52 | 
 53 | //  Optimum 'L' Filter algorithm.
 54 | //  (C) 2004, C. Bond.
 55 | //
 56 | //  Based on discussion in Kuo, "Network Analysis and Synthesis",
 57 | //  pp. 379-383. Original method due to A.Papoulis."On Monotonic
 58 | //  Response Filters", Proc. IRE, 47, Feb. 1959.
 59 | //
 60 | //  Rewritten by Vinnie Falco to change the way temporary
 61 | //  storage is allocated
 62 | //
 63 | 
 64 | //
 65 | //  This routine calculates the coefficients of the Legendre polynomial
 66 | //  of the 1st kind. It uses a recursion relation. The first few polynomials
 67 | //  are hard coded and the rest are found by recursion.
 68 | //
 69 | //  (n+1)Pn+1 = (2n+1)xPn - nPn-1 	Recursion relation.
 70 | //
 71 | void PolynomialFinderBase::legendre (double *p, int n)
 72 | {
 73 |   int i,j;
 74 | 
 75 |   if (n == 0) {
 76 |     p[0] = 1.0;
 77 |     return;
 78 |   }
 79 |   if (n == 1) {
 80 |     p[0] = 0.0;
 81 |     p[1] = 1.0;
 82 |     return;
 83 |   }
 84 |   p[0] = -0.5;
 85 |   p[1] = 0.0;
 86 |   p[2] = 1.5;
 87 | 
 88 |   if (n == 2) return;
 89 | 
 90 |   for (i=0;i<=n;i++) {
 91 |     m_aa[i] = m_bb[i] = 0.0;
 92 |   }
 93 |   m_bb[1] = 1.0;
 94 | 
 95 |   for (i=3;i<=n;i++) {
 96 |     for (j=0;j<=i;j++) {
 97 |       m_aa[j] = m_bb[j];
 98 |       m_bb[j] = p[j];
 99 |       p[j] = 0.0;
100 |     }
101 |     for (j=i-2;j>=0;j-=2) {
102 |       p[j] -= (i-1)*m_aa[j]/i;
103 |     }
104 |     for (j=i-1;j>=0;j-=2) {
105 |       p[j+1] += (2*i-1)*m_bb[j]/i;
106 |     }
107 |   }
108 | }
109 | 
110 | //
111 | //
112 | //  In the following routine n = 2k + 1 for odd 'n' and n = 2k + 2 for
113 | //  even 'n'.
114 | //
115 | //
116 | //      n   k
117 | //      -----
118 | //      1   0
119 | //      2   0
120 | //      3   1
121 | //      4   1
122 | //      5   2
123 | //      6   2
124 | //
125 | 
126 | void PolynomialFinderBase::solve (int n)
127 | {
128 |   assert (n <= m_maxN);
129 | 
130 |   double c0,c1;
131 |   int i,j,k;
132 | 
133 |   k = (n-1)/2;
134 |   //
135 |   //  form vector of 'a' constants
136 |   //
137 |   if (n & 1) {                // odd
138 |     for (i=0;i<=k;i++) {
139 |       m_a[i] = (2.0*i+1.0)/(m_sqrt2()*(k+1.0));
140 |     }
141 |   }                           // even
142 |   else {
143 |     for (i=0;i<k+1;i++) {
144 |       m_a[i] = 0.0;
145 |     }
146 |     if (k & 1) {
147 |       for (i=1;i<=k;i+=2) {
148 |         m_a[i] = (2*i+1)/sqrt(double((k+1)*(k+2)));
149 |       }
150 |     }
151 |     else {
152 |       for (i=0;i<=k;i+=2) {
153 |         m_a[i] = (2*i+1)/sqrt(double((k+1)*(k+2)));
154 |       }
155 |     }
156 |   }
157 |   for (i=0;i<=n;i++){
158 |     m_s[i] = 0.0;
159 |     m_w[i] = 0.0;
160 |   }
161 |   //
162 |   // form s[] = sum of a[i]*P[i]
163 |   //
164 |   m_s[0] = m_a[0];
165 |   m_s[1] = m_a[1];
166 |   for (i=2;i<=k;i++) {
167 |     legendre(m_p,i);
168 |     for (j=0;j<=i;j++) {
169 |       m_s[j] += m_a[i]*m_p[j];
170 |     }
171 |   }
172 |   //
173 |   //  form v[] = square of s[]
174 |   //
175 |   for (i=0;i<=2*k+2;i++) {
176 |     m_v[i] = 0.0;
177 |   }
178 |   for (i=0;i<=k;i++) {
179 |     for (j=0;j<=k;j++) {
180 |       m_v[i+j] += m_s[i]*m_s[j];    
181 |     }
182 |   }
183 |   //
184 |   //  modify integrand for even 'n'
185 |   //
186 |   m_v[2*k+1] = 0.0;
187 |   if ((n & 1) == 0) {
188 |     for (i=n;i>=0;i--) {
189 |       m_v[i+1] += m_v[i];
190 |     }
191 |   }
192 |   //
193 |   //  form integral of v[]
194 |   //
195 |   for (i=n+1;i>=0;i--) {
196 |     m_v[i+1] = m_v[i]/(double)(i+1.0);
197 |   }
198 |   m_v[0] = 0.0;
199 |   //
200 |   // clear s[] for use in computing definite integral
201 |   //
202 |   for (i=0;i<(n+2);i++){ 
203 |     m_s[i] = 0.0;
204 |   }
205 |   m_s[0] = -1.0;
206 |   m_s[1] = 2.0;
207 |   //
208 |   //  calculate definite integral
209 |   //
210 |   for (i=1;i<=n;i++) {
211 |     if (i > 1) {
212 |       c0 = -m_s[0];
213 |       for (j=1;j<i+1;j++) {
214 |         c1 = -m_s[j] + 2.0*m_s[j-1];
215 |         m_s[j-1] = c0;
216 |         c0 = c1;
217 |       }
218 |       c1 = 2.0*m_s[i];
219 |       m_s[i] = c0;
220 |       m_s[i+1] = c1;
221 |     }
222 |     for (j=i;j>0;j--) {
223 |       m_w[j] += (m_v[i]*m_s[j]);
224 |     }
225 |   }
226 |   if ((n & 1) == 0) m_w[1] = 0.0;
227 | }
228 | 
229 | //------------------------------------------------------------------------------
230 | 
231 | AnalogLowPass::AnalogLowPass ()
232 |   : m_numPoles (-1)
233 | {
234 |   setNormal (0, 1);
235 | }
236 | 
237 | void AnalogLowPass::design (int numPoles,
238 |                             WorkspaceBase* w)
239 | {
240 |   if (m_numPoles != numPoles)
241 |   {
242 |     m_numPoles = numPoles;
243 | 
244 |     reset ();
245 | 
246 |     PolynomialFinderBase& poly (w->poly);
247 |     RootFinderBase& poles (w->roots);
248 | 
249 |     poly.solve (numPoles);
250 |     int degree = numPoles * 2;
251 | 
252 |     poles.coef()[0] = 1 + poly.coef()[0];
253 |     poles.coef()[1] = 0;
254 |     for (int i = 1; i <= degree; ++i)
255 |     {
256 |       poles.coef()[2*i] = poly.coef()[i] * ((i & 1) ? -1 : 1);
257 |       poles.coef()[2*i+1] = 0;
258 |     }
259 |     poles.solve (degree);
260 | 
261 |     int j = 0;
262 |     for (int i = 0; i < degree; ++i)
263 |       if (poles.root()[i].real() <= 0)
264 |         poles.root()[j++] = poles.root()[i];
265 |     // sort descending imag() and cut degree in half
266 |     poles.sort (degree/2);
267 | 
268 |     const int pairs = numPoles / 2;
269 |     for (int i = 0; i < pairs; ++i)
270 |     {
271 |       complex_t c = poles.root()[i];
272 |       addPoleZeroConjugatePairs (c, infinity());
273 |     }
274 | 
275 |     if (numPoles & 1)
276 |       add (poles.root()[pairs].real(), infinity());
277 |   }
278 | }
279 | 
280 | //------------------------------------------------------------------------------
281 | 
282 | void LowPassBase::setup (int order,
283 |                          double sampleRate,
284 |                          double cutoffFrequency,
285 |                          WorkspaceBase* w)
286 | {
287 |   m_analogProto.design (order, w);
288 | 
289 |   LowPassTransform (cutoffFrequency / sampleRate,
290 |                     m_digitalProto,
291 |                     m_analogProto);
292 | 
293 |   Cascade::setLayout (m_digitalProto);
294 | }
295 | 
296 | void HighPassBase::setup (int order,
297 |                           double sampleRate,
298 |                           double cutoffFrequency,
299 |                           WorkspaceBase* w)
300 | {
301 |   m_analogProto.design (order, w);
302 | 
303 |   HighPassTransform (cutoffFrequency / sampleRate,
304 |                      m_digitalProto,
305 |                      m_analogProto);
306 | 
307 |   Cascade::setLayout (m_digitalProto);
308 | }
309 | 
310 | void BandPassBase::setup (int order,
311 |                           double sampleRate,
312 |                           double centerFrequency,
313 |                           double widthFrequency,
314 |                           WorkspaceBase* w)
315 | {
316 |   m_analogProto.design (order, w);
317 | 
318 |   BandPassTransform (centerFrequency / sampleRate,
319 |                      widthFrequency / sampleRate,
320 |                      m_digitalProto,
321 |                      m_analogProto);
322 | 
323 |   Cascade::setLayout (m_digitalProto);
324 | }
325 | 
326 | void BandStopBase::setup (int order,
327 |                           double sampleRate,
328 |                           double centerFrequency,
329 |                           double widthFrequency,
330 |                           WorkspaceBase* w)
331 | {
332 |   m_analogProto.design (order, w);
333 | 
334 |   BandStopTransform (centerFrequency / sampleRate,
335 |                      widthFrequency / sampleRate,
336 |                      m_digitalProto,
337 |                      m_analogProto);
338 | 
339 |   Cascade::setLayout (m_digitalProto);
340 | }
341 | 
342 | }
343 | 
344 | }
345 | 


--------------------------------------------------------------------------------
/src/DspFilters/MathSupplement.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_MATHSUPPLEMENT_H
 37 | #define DSPFILTERS_MATHSUPPLEMENT_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | 
 41 | namespace Dsp {
 42 | 
 43 | const double doublePi		=3.1415926535897932384626433832795028841971;
 44 | const double doublePi_2	=1.5707963267948966192313216916397514420986;
 45 | const double doubleLn2  =0.69314718055994530941723212145818;//?????
 46 | const double doubleLn10	=2.3025850929940456840179914546844;//??????
 47 | 
 48 | typedef std::complex<double> complex_t;
 49 | typedef std::pair<complex_t, complex_t> complex_pair_t;
 50 | 
 51 | template<typename Real>
 52 | inline std::complex<Real> solve_quadratic_1 (Real a, Real b, Real c)
 53 | {
 54 |   return (-b + sqrt (std::complex<Real> (b*b - 4*a*c, 0))) / (2. * a);
 55 | }
 56 | 
 57 | template<typename Real>
 58 | inline std::complex<Real> solve_quadratic_2 (Real a, Real b, Real c)
 59 | {
 60 |   return (-b - sqrt (std::complex<Real> (b*b - 4*a*c, 0))) / (2. * a);
 61 | }
 62 | 
 63 | inline const complex_t infinity()
 64 | {
 65 |   return complex_t (std::numeric_limits<double>::infinity());
 66 | }
 67 | 
 68 | inline const complex_t adjust_imag (const complex_t& c)
 69 | {
 70 |   if (fabs (c.imag()) < 1e-30)
 71 |     return complex_t (c.real(), 0);
 72 |   else
 73 |     return c;
 74 | }
 75 | 
 76 | template <typename Ty, typename To>
 77 | inline std::complex<Ty> addmul (const std::complex<Ty>& c,
 78 |                                 Ty v,
 79 |                                 const std::complex<To>& c1)
 80 | {
 81 |   return std::complex <Ty> (
 82 |     c.real() + v * c1.real(), c.imag() + v * c1.imag());
 83 | }
 84 | 
 85 | template <typename Ty>
 86 | inline std::complex<Ty> recip (const std::complex<Ty>& c)
 87 | {
 88 |   Ty n = 1.0 / std::norm (c);
 89 |   
 90 |   return std::complex<Ty> (n * c.real(), n * c.imag());
 91 | }
 92 | 
 93 | template <typename Ty>
 94 | inline Ty asinh (Ty x)
 95 | {
 96 |   return log (x + std::sqrt (x * x + 1 ));
 97 | }
 98 | 
 99 | template <typename Ty>
100 | inline Ty acosh (Ty x)
101 | {
102 |   return log (x + std::sqrt (x * x - 1));
103 | }
104 | 
105 | template <typename Ty>
106 | inline bool is_nan (Ty v)
107 | {
108 |   return !(v == v);
109 | }
110 | 
111 | template <>
112 | inline bool is_nan<complex_t> (complex_t v)
113 | {
114 |   return Dsp::is_nan (v.real()) || Dsp::is_nan (v.imag());
115 | }
116 | 
117 | //------------------------------------------------------------------------------
118 | 
119 | /*
120 |  * Hack to prevent denormals
121 |  *
122 |  */
123 | 
124 | //const double anti_denormal_vsa = 1e-16; // doesn't prevent denormals
125 | //const double anti_denormal_vsa = 0;
126 | const double anti_denormal_vsa = 1e-8;
127 | 
128 | class DenormalPrevention
129 | {
130 | public:
131 |   DenormalPrevention ()
132 |     : m_v (anti_denormal_vsa)
133 |   {
134 |   }
135 | 
136 |   // small alternating current
137 |   inline double ac ()
138 |   {
139 |     return m_v = -m_v;
140 |   }
141 | 
142 |   // small direct current
143 |   static inline double dc ()
144 |   {
145 |     return anti_denormal_vsa;
146 |   }
147 | 
148 | private:
149 |   double m_v;
150 | };
151 | 
152 | }
153 | 
154 | #endif
155 | 


--------------------------------------------------------------------------------
/src/DspFilters/Param.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/Design.h"
 38 | 
 39 | #include <stdexcept>
 40 | #include <sstream>
 41 | #include <iostream>
 42 | #include <iomanip>
 43 | 
 44 | namespace Dsp {
 45 | 
 46 | ParamInfo::ParamInfo ()
 47 | {
 48 |   throw std::logic_error ("invalid usage of ParamInfo");
 49 | }
 50 | 
 51 | double ParamInfo::clamp (double nativeValue) const
 52 | {
 53 |   const double minValue = toNativeValue (0);
 54 |   const double maxValue = toNativeValue (1);
 55 |   if (nativeValue < minValue)
 56 |     nativeValue = minValue;
 57 |   else if (nativeValue > maxValue)
 58 |     nativeValue = maxValue;
 59 |   return nativeValue;
 60 | }
 61 | 
 62 | //------------------------------------------------------------------------------
 63 | 
 64 | double ParamInfo::Int_toControlValue (double nativeValue) const
 65 | {
 66 |   return (nativeValue - m_arg1) / (m_arg2 - m_arg1);
 67 | }
 68 | 
 69 | double ParamInfo::Int_toNativeValue (double controlValue) const
 70 | {
 71 |   return std::floor (m_arg1 + controlValue * (m_arg2 - m_arg1) + 0.5);
 72 | }
 73 | 
 74 | //------------------------------------------------------------------------------
 75 | 
 76 | double ParamInfo::Real_toControlValue (double nativeValue) const
 77 | {
 78 |   return (nativeValue - m_arg1) / (m_arg2 - m_arg1);
 79 | }
 80 | 
 81 | double ParamInfo::Real_toNativeValue (double controlValue) const
 82 | {
 83 |   return m_arg1 + controlValue * (m_arg2 - m_arg1);
 84 | }
 85 | 
 86 | //------------------------------------------------------------------------------
 87 | 
 88 | double ParamInfo::Log_toControlValue (double nativeValue) const
 89 | {
 90 |   const double base = 1.5;
 91 |   double l0 = log (m_arg1) / log (base);
 92 |   double l1 = log (m_arg2) / log (base);
 93 |   return (log (nativeValue) / log(base) - l0) / (l1 - l0);
 94 | }
 95 | 
 96 | double ParamInfo::Log_toNativeValue (double controlValue) const
 97 | {
 98 |   const double base = 1.5;
 99 |   double l0 = log (m_arg1) / log (base);
100 |   double l1 = log (m_arg2) / log (base);
101 |   return pow (base, l0 + controlValue * (l1 - l0));
102 | }
103 | 
104 | //------------------------------------------------------------------------------
105 | 
106 | double ParamInfo::Pow2_toControlValue (double nativeValue) const
107 | {
108 |   return ((log (nativeValue) / log (2.)) - m_arg1) / (m_arg2 - m_arg1);
109 | }
110 | 
111 | double ParamInfo::Pow2_toNativeValue (double controlValue) const
112 | {
113 |   return pow (2., (controlValue * (m_arg2 - m_arg1)) + m_arg1);
114 | }
115 | 
116 | //------------------------------------------------------------------------------
117 | 
118 | std::string ParamInfo::Int_toString (double nativeValue) const
119 | {
120 |   std::ostringstream os;
121 |   os << int (nativeValue);
122 |   return os.str();
123 | }
124 | 
125 | std::string ParamInfo::Hz_toString (double nativeValue) const
126 | {
127 |   std::ostringstream os;
128 |   os << int (nativeValue) << " Hz";
129 |   return os.str();
130 | }
131 | 
132 | std::string ParamInfo::Real_toString (double nativeValue) const
133 | {
134 |   std::ostringstream os;
135 |   os << std::fixed << std::setprecision(3) << nativeValue;
136 |   return os.str();
137 | }
138 | 
139 | std::string ParamInfo::Db_toString (double nativeValue) const
140 | {
141 |   const double af = fabs (nativeValue);
142 |   int prec;
143 |   if (af < 1)
144 |     prec = 3;
145 |   else if (af < 10)
146 |     prec = 2;
147 |   else
148 |     prec = 1;
149 |   std::ostringstream os;
150 |   os << std::fixed << std::setprecision (prec) << nativeValue << " dB";
151 |   return os.str();
152 | }
153 | 
154 | //------------------------------------------------------------------------------
155 | 
156 | ParamInfo ParamInfo::defaultSampleRateParam ()
157 | {
158 |   return ParamInfo (idSampleRate, "Fs", "Sample Rate",
159 |                      11025, 192000, 44100,
160 |                      &ParamInfo::Real_toControlValue,
161 |                      &ParamInfo::Real_toNativeValue,
162 |                      &ParamInfo::Hz_toString);
163 | }
164 | 
165 | ParamInfo ParamInfo::defaultCutoffFrequencyParam ()
166 | {
167 |   return ParamInfo (idFrequency, "Fc", "Cutoff Frequency",
168 |                      10, 22040, 2000,
169 |                      &ParamInfo::Log_toControlValue,
170 |                      &ParamInfo::Log_toNativeValue,
171 |                      &ParamInfo::Hz_toString);
172 | }
173 | 
174 | ParamInfo ParamInfo::defaultCenterFrequencyParam ()
175 | {
176 |   return ParamInfo (idFrequency, "Fc", "Center Frequency",
177 |                      10, 22040, 2000,
178 |                      &ParamInfo::Log_toControlValue,
179 |                      &ParamInfo::Log_toNativeValue,
180 |                      &ParamInfo::Hz_toString);
181 | }
182 | 
183 | ParamInfo ParamInfo::defaultQParam ()
184 | {
185 |   return ParamInfo (idQ, "Q", "Resonance",
186 |                      -4, 4, 1,
187 |                      &ParamInfo::Pow2_toControlValue,
188 |                      &ParamInfo::Pow2_toNativeValue,
189 |                      &ParamInfo::Real_toString);
190 | }
191 | 
192 | ParamInfo ParamInfo::defaultBandwidthParam ()
193 | {
194 |   return ParamInfo (idBandwidth, "BW", "Bandwidth (Octaves)",
195 |                      -4, 4, 1,
196 |                      &ParamInfo::Pow2_toControlValue,
197 |                      &ParamInfo::Pow2_toNativeValue,
198 |                      &ParamInfo::Real_toString);
199 | }
200 | 
201 | ParamInfo ParamInfo::defaultBandwidthHzParam ()
202 | {
203 |   return ParamInfo (idBandwidthHz, "BW", "Bandwidth (Hz)",
204 |                      10, 22040, 1720,
205 |                      &ParamInfo::Log_toControlValue,
206 |                      &ParamInfo::Log_toNativeValue,
207 |                      &ParamInfo::Hz_toString);
208 | }
209 | 
210 | ParamInfo ParamInfo::defaultGainParam ()
211 | {
212 |   return ParamInfo (idGain, "Gain", "Gain",
213 |                      -24, 24, -6,
214 |                      &ParamInfo::Real_toControlValue,
215 |                      &ParamInfo::Real_toNativeValue,
216 |                      &ParamInfo::Db_toString);
217 | }
218 | 
219 | ParamInfo ParamInfo::defaultSlopeParam ()
220 | {
221 |   return ParamInfo (idSlope, "Slope", "Slope",
222 |                      -2, 2, 1,
223 |                      &ParamInfo::Pow2_toControlValue,
224 |                      &ParamInfo::Pow2_toNativeValue,
225 |                      &ParamInfo::Real_toString);
226 | }
227 | 
228 | ParamInfo ParamInfo::defaultRippleDbParam ()
229 | {
230 |   return ParamInfo (idRippleDb, "Ripple", "Ripple dB",
231 |                      0.001, 12, 0.01,
232 |                      &ParamInfo::Real_toControlValue,
233 |                      &ParamInfo::Real_toNativeValue,
234 |                      &ParamInfo::Db_toString);
235 | }
236 | 
237 | ParamInfo ParamInfo::defaultStopDbParam ()
238 | {
239 |   return ParamInfo (idStopDb, "Stop", "Stopband dB",
240 |                      3, 60, 48,
241 |                      &ParamInfo::Real_toControlValue,
242 |                      &ParamInfo::Real_toNativeValue,
243 |                      &ParamInfo::Db_toString);
244 | }
245 | 
246 | ParamInfo ParamInfo::defaultRolloffParam ()
247 | {
248 |   return ParamInfo (idRolloff, "W", "Transition Width",
249 |                      -16, 4, 0,
250 |                      &ParamInfo::Real_toControlValue,
251 |                      &ParamInfo::Real_toNativeValue,
252 |                      &ParamInfo::Real_toString);
253 | }
254 | 
255 | ParamInfo ParamInfo::defaultPoleRhoParam ()
256 | {
257 |   return ParamInfo (idPoleRho, "Pd", "Pole Distance",
258 |                      0, 1, 0.5,
259 |                      &ParamInfo::Real_toControlValue,
260 |                      &ParamInfo::Real_toNativeValue,
261 |                      &ParamInfo::Real_toString);
262 | }
263 | 
264 | ParamInfo ParamInfo::defaultPoleThetaParam ()
265 | {
266 |   return ParamInfo (idPoleTheta, "Pa", "Pole Angle",
267 |                      0, doublePi, doublePi/2,
268 |                      &ParamInfo::Real_toControlValue,
269 |                      &ParamInfo::Real_toNativeValue,
270 |                      &ParamInfo::Real_toString);
271 | }
272 | 
273 | ParamInfo ParamInfo::defaultZeroRhoParam ()
274 | {
275 |   return ParamInfo (idZeroRho, "Pd", "Zero Distance",
276 |                      0, 1, 0.5,
277 |                      &ParamInfo::Real_toControlValue,
278 |                      &ParamInfo::Real_toNativeValue,
279 |                      &ParamInfo::Real_toString);
280 | }
281 | 
282 | ParamInfo ParamInfo::defaultZeroThetaParam ()
283 | {
284 |   return ParamInfo (idZeroTheta, "Pa", "Zero Angle",
285 |                      0, doublePi, doublePi/2,
286 |                      &ParamInfo::Real_toControlValue,
287 |                      &ParamInfo::Real_toNativeValue,
288 |                      &ParamInfo::Real_toString);
289 | }
290 | 
291 | ParamInfo ParamInfo::defaultPoleRealParam ()
292 | {
293 |   return ParamInfo (idPoleReal, "A1", "Pole Real",
294 |                      -1, 1, 0.25,
295 |                      &ParamInfo::Real_toControlValue,
296 |                      &ParamInfo::Real_toNativeValue,
297 |                      &ParamInfo::Real_toString);
298 | }
299 | 
300 | ParamInfo ParamInfo::defaultZeroRealParam ()
301 | {
302 |   return ParamInfo (idZeroReal, "B1", "Zero Real",
303 |                      -1, 1, -0.25,
304 |                      &ParamInfo::Real_toControlValue,
305 |                      &ParamInfo::Real_toNativeValue,
306 |                      &ParamInfo::Real_toString);
307 | }
308 | }
309 | 
310 | 


--------------------------------------------------------------------------------
/src/DspFilters/Params.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_PARAMS_H
 37 | #define DSPFILTERS_PARAMS_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Types.h"
 41 | 
 42 | namespace Dsp {
 43 | 
 44 | /*
 45 |  * System for abstracting parameterizable filter specifications.
 46 |  *
 47 |  * This provides a "GUI-friendly" layer to the filters. Note that
 48 |  * it is not necessary to use this layer, it is possible to instantiate
 49 |  * the filters and their associated processing state directly,
 50 |  * and bypass the overhead for this API if it is not needed.
 51 |  *
 52 |  */
 53 | 
 54 | // Unique IDs to help identify parameters
 55 | enum ParamID
 56 | {
 57 |   idSampleRate,
 58 |   idFrequency,
 59 |   idQ,
 60 |   idBandwidth,
 61 |   idBandwidthHz,
 62 |   idGain,
 63 |   idSlope,
 64 |   idOrder,
 65 |   idRippleDb,
 66 |   idStopDb,
 67 |   idRolloff,
 68 | 
 69 |   idPoleRho,
 70 |   idPoleTheta,
 71 |   idZeroRho,
 72 |   idZeroTheta,
 73 | 
 74 |   idPoleReal,
 75 |   idZeroReal
 76 | };
 77 | 
 78 | enum
 79 | {
 80 |   maxParameters = 8
 81 | };
 82 | 
 83 | struct Params
 84 | {
 85 |   void clear ()
 86 |   {
 87 |     for (int i = 0; i < maxParameters; ++i)
 88 |       value[i] = 0;
 89 |   }
 90 | 
 91 |   double& operator[] (int index)
 92 |   {
 93 |     return value[index];
 94 |   }
 95 | 
 96 |   const double& operator[] (int index) const
 97 |   {
 98 |     return value[index];
 99 |   }
100 | 
101 |   double value[maxParameters];
102 | };
103 | 
104 | //
105 | // Provides meta-information about a filter parameter
106 | // to achieve run-time introspection.
107 | //
108 | class ParamInfo
109 | {
110 | public:
111 |   typedef double (ParamInfo::*toControlValue_t) (double) const;
112 |   typedef double (ParamInfo::*toNativeValue_t) (double) const;
113 |   typedef std::string (ParamInfo::*toString_t) (double) const;
114 | 
115 |   // dont use this one
116 |   ParamInfo (); // throws std::logic_error
117 | 
118 |   ParamInfo (ParamID id,
119 |               const char* szLabel,
120 |               const char* szName,
121 |               double arg1,
122 |               double arg2,
123 |               double defaultNativeValue,
124 |               toControlValue_t toControlValue_proc,
125 |               toNativeValue_t toNativeValue_proc,
126 |               toString_t toString_proc)
127 |                   : m_id (id)
128 |     , m_szLabel (szLabel)
129 |     , m_szName (szName)
130 |     , m_arg1 (arg1)
131 |     , m_arg2 (arg2)
132 |     , m_defaultNativeValue (defaultNativeValue)
133 |     , m_toControlValue (toControlValue_proc)
134 |     , m_toNativeValue (toNativeValue_proc)
135 |     , m_toString (toString_proc)
136 |   {
137 |   }
138 | 
139 |   // Used to identify well-known parameters (like cutoff frequency)
140 |   ParamID getId () const
141 |   {
142 |     return m_id;
143 |   }
144 | 
145 |   // Returns a short label suitable for placement on a control
146 |   const char* getLabel () const
147 |   {
148 |     return m_szLabel;
149 |   }
150 | 
151 |   // Returns the full name
152 |   const char* getName () const
153 |   {
154 |     return m_szName;
155 |   }
156 | 
157 |   double getDefaultValue () const
158 |   {
159 |     return m_defaultNativeValue;
160 |   }
161 | 
162 |   //
163 |   // Control value is always in the range [0..1]
164 |   //
165 |   double toControlValue (double nativeValue) const
166 |   {
167 |     return (this->*m_toControlValue) (nativeValue);
168 |   }
169 | 
170 |   //
171 |   // Native value is in filter-specific units. For example,
172 |   // cutoff frequency would probably be in Hertz.
173 |   //
174 |   double toNativeValue (double controlValue) const
175 |   {
176 |     return (this->*m_toNativeValue) (controlValue);
177 |   }
178 | 
179 |   std::string toString (double nativeValue) const
180 |   {
181 |     return (this->*m_toString) (nativeValue);
182 |   }
183 | 
184 |   double clamp (double nativeValue) const;
185 | 
186 |   //
187 |   // These routines are used as function pointers when
188 |   // constructing the various ParamInfo used by filters
189 |   //
190 | 
191 |   double Int_toControlValue (double nativeValue) const;
192 |   double Int_toNativeValue (double controlValue) const;
193 | 
194 |   double Real_toControlValue (double nativeValue) const;
195 |   double Real_toNativeValue (double controlValue) const;
196 | 
197 |   double Log_toControlValue (double nativeValue) const;
198 |   double Log_toNativeValue (double controlValue) const;
199 | 
200 |   double Pow2_toControlValue (double nativeValue) const;
201 |   double Pow2_toNativeValue (double controlValue) const;
202 | 
203 |   std::string Int_toString (double nativeValue) const;
204 |   std::string Hz_toString (double nativeValue) const;
205 |   std::string Real_toString (double nativeValue) const;
206 |   std::string Db_toString (double nativeValue) const;
207 | 
208 |   //
209 |   // Creates the specified ParamInfo
210 |   //
211 | 
212 |   static ParamInfo defaultSampleRateParam ();
213 |   static ParamInfo defaultCutoffFrequencyParam ();
214 |   static ParamInfo defaultCenterFrequencyParam ();
215 |   static ParamInfo defaultQParam ();
216 |   static ParamInfo defaultBandwidthParam ();
217 |   static ParamInfo defaultBandwidthHzParam ();
218 |   static ParamInfo defaultGainParam ();
219 |   static ParamInfo defaultSlopeParam ();
220 |   static ParamInfo defaultRippleDbParam ();
221 |   static ParamInfo defaultStopDbParam ();
222 |   static ParamInfo defaultRolloffParam ();
223 |   static ParamInfo defaultPoleRhoParam ();
224 |   static ParamInfo defaultPoleThetaParam ();
225 |   static ParamInfo defaultZeroRhoParam ();
226 |   static ParamInfo defaultZeroThetaParam ();
227 |   static ParamInfo defaultPoleRealParam ();
228 |   static ParamInfo defaultZeroRealParam ();
229 | 
230 | private:
231 |   ParamID m_id;
232 |   const char* m_szLabel;
233 |   const char* m_szName;
234 |   double m_arg1;
235 |   double m_arg2;
236 |   double m_defaultNativeValue;
237 |   toControlValue_t m_toControlValue;
238 |   toNativeValue_t m_toNativeValue;
239 |   toString_t m_toString;
240 | };
241 | 
242 | }
243 | 
244 | #endif
245 | 


--------------------------------------------------------------------------------
/src/DspFilters/PoleFilter.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/PoleFilter.h"
 38 | 
 39 | namespace Dsp {
 40 | 
 41 | //------------------------------------------------------------------------------
 42 | 
 43 | complex_t LowPassTransform::transform (complex_t c)
 44 | {
 45 |   if (c == infinity())
 46 |     return complex_t (-1, 0);
 47 | 
 48 |   // frequency transform
 49 |   c = f * c; 
 50 |   
 51 |   // bilinear low pass transform
 52 |   return (1. + c) / (1. - c);
 53 | }
 54 | 
 55 | LowPassTransform::LowPassTransform (double fc,
 56 |                                     LayoutBase& digital,
 57 |                                     LayoutBase const& analog)
 58 | {
 59 |   digital.reset ();
 60 | 
 61 |   // prewarp
 62 |   f = tan (doublePi * fc);
 63 | 
 64 |   const int numPoles = analog.getNumPoles ();
 65 |   const int pairs = numPoles / 2;
 66 |   for (int i = 0; i < pairs; ++i)
 67 |   {
 68 |     const PoleZeroPair& pair = analog[i];
 69 |     digital.addPoleZeroConjugatePairs (transform (pair.poles.first),
 70 |                                        transform (pair.zeros.first));
 71 |   }
 72 | 
 73 |   if (numPoles & 1)
 74 |   {
 75 |     const PoleZeroPair& pair = analog[pairs];
 76 |     digital.add (transform (pair.poles.first),
 77 |                  transform (pair.zeros.first));
 78 |   }
 79 | 
 80 |   digital.setNormal (analog.getNormalW(),
 81 |                      analog.getNormalGain());
 82 | }
 83 | 
 84 | //------------------------------------------------------------------------------
 85 | 
 86 | complex_t HighPassTransform::transform (complex_t c)
 87 | {
 88 |   if (c == infinity())
 89 |     return complex_t (1, 0);
 90 | 
 91 |   // frequency transform
 92 |   c = f * c; 
 93 | 
 94 |   // bilinear high pass transform
 95 |   return - (1. + c) / (1. - c);
 96 | }
 97 | 
 98 | HighPassTransform::HighPassTransform (double fc,
 99 |                                       LayoutBase& digital,
100 |                                       LayoutBase const& analog)
101 | {
102 |   digital.reset ();
103 | 
104 |   // prewarp
105 |   f = 1. / tan (doublePi * fc);
106 | 
107 |   const int numPoles = analog.getNumPoles ();
108 |   const int pairs = numPoles / 2;
109 |   for (int i = 0; i < pairs; ++i)
110 |   {
111 |     const PoleZeroPair& pair = analog[i];
112 |     digital.addPoleZeroConjugatePairs (transform (pair.poles.first),
113 |                                        transform (pair.zeros.first));
114 |   }
115 |   
116 |   if (numPoles & 1)
117 |   {
118 |     const PoleZeroPair& pair = analog[pairs];
119 |     digital.add (transform (pair.poles.first),
120 |                  transform (pair.zeros.first));
121 |   }
122 | 
123 |   digital.setNormal (doublePi - analog.getNormalW(),
124 |                      analog.getNormalGain());
125 | }
126 | 
127 | //------------------------------------------------------------------------------
128 | 
129 | BandPassTransform::BandPassTransform (double fc,
130 |                                       double fw,
131 |                                       LayoutBase& digital,
132 |                                       LayoutBase const& analog)
133 | {
134 |   // handle degenerate cases efficiently
135 |   // THIS DOESNT WORK because the cascade states won't match
136 | #if 0
137 |   const double fw_2 = fw / 2;
138 |   if (fc - fw_2 < 0)
139 |   {
140 |     LowPassTransform::transform (fc + fw_2, digital, analog);
141 |   }
142 |   else if (fc + fw_2 >= 0.5)
143 |   {
144 |     HighPassTransform::transform (fc - fw_2, digital, analog);
145 |   }
146 |   else
147 | #endif
148 | 
149 |   digital.reset ();
150 | 
151 |   const double ww = 2 * doublePi * fw;
152 | 
153 |   // pre-calcs
154 |   wc2 = 2 * doublePi * fc - (ww / 2);
155 |   wc  = wc2 + ww;
156 | 
157 |   // what is this crap?
158 |   if (wc2 < 1e-8)
159 |       wc2 = 1e-8;
160 |   if (wc  > doublePi-1e-8)
161 |       wc  = doublePi-1e-8;
162 | 
163 |   a =     cos ((wc + wc2) * 0.5) /
164 |           cos ((wc - wc2) * 0.5);
165 |   b = 1 / tan ((wc - wc2) * 0.5);
166 |   a2 = a * a;
167 |   b2 = b * b;
168 |   ab = a * b;
169 |   ab_2 = 2 * ab;
170 | 
171 |   const int numPoles = analog.getNumPoles ();
172 |   const int pairs = numPoles / 2;
173 |   for (int i = 0; i < pairs; ++i)
174 |   {
175 |     const PoleZeroPair& pair = analog[i];
176 |     ComplexPair p1 = transform (pair.poles.first);
177 |     ComplexPair z1 = transform (pair.zeros.first);
178 | 
179 |     //
180 |     // Optimize out the calculations for conjugates for Release builds
181 |     //
182 | #ifndef NDEBUG
183 |     ComplexPair p2 = transform (pair.poles.second);
184 |     ComplexPair z2 = transform (pair.zeros.second);
185 |     assert (p2.first == std::conj (p1.first));
186 |     assert (p2.second == std::conj (p1.second));
187 | #endif
188 | 
189 |     digital.addPoleZeroConjugatePairs (p1.first, z1.first);
190 |     digital.addPoleZeroConjugatePairs (p1.second, z1.second);
191 |   }
192 | 
193 |   if (numPoles & 1)
194 |   {
195 |     ComplexPair poles = transform (analog[pairs].poles.first);
196 |     ComplexPair zeros = transform (analog[pairs].zeros.first);
197 | 
198 |     digital.add (poles, zeros);
199 |   }
200 | 
201 |   double wn = analog.getNormalW();
202 |   digital.setNormal (2 * atan (sqrt (tan ((wc + wn)* 0.5) * tan((wc2 + wn)* 0.5))),
203 |                      analog.getNormalGain());
204 | }
205 | 
206 | ComplexPair BandPassTransform::transform (complex_t c)
207 | {
208 |   if (c == infinity())
209 |     return ComplexPair (-1, 1);
210 | 
211 |   c = (1. + c) / (1. - c); // bilinear
212 | 
213 |   complex_t v = 0;
214 |   v = addmul (v, 4 * (b2 * (a2 - 1) + 1), c);
215 |   v += 8 * (b2 * (a2 - 1) - 1);
216 |   v *= c;
217 |   v += 4 * (b2 * (a2 - 1) + 1);
218 |   v = std::sqrt (v);
219 | 
220 |   complex_t u = -v;
221 |   u = addmul (u, ab_2, c);
222 |   u += ab_2;
223 | 
224 |   v = addmul (v, ab_2, c);
225 |   v += ab_2;
226 | 
227 |   complex_t d = 0;
228 |   d = addmul (d, 2 * (b - 1), c) + 2 * (1 + b);
229 | 
230 |   return ComplexPair (u/d, v/d);
231 | }
232 | 
233 | //------------------------------------------------------------------------------
234 | 
235 | BandStopTransform::BandStopTransform (double fc,
236 |                                       double fw,
237 |                                       LayoutBase& digital,
238 |                                       LayoutBase const& analog)
239 | {
240 |   digital.reset ();
241 | 
242 |   const double ww = 2 * doublePi * fw;
243 | 
244 |   wc2 = 2 * doublePi * fc - (ww / 2);
245 |   wc  = wc2 + ww;
246 | 
247 |   // this is crap
248 |   if (wc2 < 1e-8)
249 |       wc2 = 1e-8;
250 |   if (wc  > doublePi-1e-8)
251 |       wc  = doublePi-1e-8;
252 | 
253 |   a = cos ((wc + wc2) * .5) /
254 |       cos ((wc - wc2) * .5);
255 |   b = tan ((wc - wc2) * .5);
256 |   a2 = a * a;
257 |   b2 = b * b;
258 | 
259 |   const int numPoles = analog.getNumPoles ();
260 |   const int pairs = numPoles / 2;
261 |   for (int i = 0; i < pairs; ++i)
262 |   {
263 |     const PoleZeroPair& pair = analog[i];
264 |     ComplexPair p  = transform (pair.poles.first);
265 |     ComplexPair z  = transform (pair.zeros.first);
266 | 
267 |     //
268 |     // Optimize out the calculations for conjugates for Release builds
269 |     //
270 | #ifdef NDEBUG
271 |     // trick to get the conjugate
272 |     if (z.second == z.first)
273 |       z.second = std::conj (z.first);
274 | 
275 | #else
276 |     // Do the full calculation to verify correctness
277 |     ComplexPair pc = transform (analog[i].poles.second);
278 |     ComplexPair zc = transform (analog[i].zeros.second);
279 | 
280 |     // get the conjugates into pc and zc
281 |     if (zc.first == z.first)
282 |       std::swap (zc.first, zc.second);
283 | 
284 |     assert (pc.first  == std::conj (p.first));
285 |     assert (pc.second == std::conj (p.second));
286 |     assert (zc.first  == std::conj (z.first));
287 |     assert (zc.second == std::conj (z.second));
288 | 
289 | #endif
290 | 
291 |     digital.addPoleZeroConjugatePairs (p.first, z.first);
292 |     digital.addPoleZeroConjugatePairs (p.second, z.second);
293 |   }
294 | 
295 |   if (numPoles & 1)
296 |   {
297 |     ComplexPair poles = transform (analog[pairs].poles.first);
298 |     ComplexPair zeros = transform (analog[pairs].zeros.first);
299 | 
300 |     digital.add (poles, zeros);
301 |   }
302 | 
303 |   if (fc < 0.25)
304 |     digital.setNormal (doublePi, analog.getNormalGain());
305 |   else
306 |     digital.setNormal (0, analog.getNormalGain());
307 | }
308 | 
309 | ComplexPair BandStopTransform::transform (complex_t c)
310 | {
311 |   if (c == infinity())
312 |     c = -1;
313 |   else
314 |     c = (1. + c) / (1. - c); // bilinear
315 | 
316 |   complex_t u (0);
317 |   u = addmul (u, 4 * (b2 + a2 - 1), c);
318 |   u += 8 * (b2 - a2 + 1);
319 |   u *= c;
320 |   u += 4 * (a2 + b2 - 1);
321 |   u = std::sqrt (u);
322 | 
323 |   complex_t v = u * -.5;
324 |   v += a;
325 |   v = addmul (v, -a, c);
326 | 
327 |   u *= .5;
328 |   u += a;
329 |   u = addmul (u, -a, c);
330 |   
331 |   complex_t d (b + 1);
332 |   d = addmul (d, b-1, c);
333 | 
334 |   return ComplexPair (u/d, v/d);
335 | }
336 | 
337 | }
338 | 


--------------------------------------------------------------------------------
/src/DspFilters/PoleFilter.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_POLEFILTER_H
 37 | #define DSPFILTERS_POLEFILTER_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/MathSupplement.h"
 41 | #include "DspFilters/Cascade.h"
 42 | 
 43 | namespace Dsp {
 44 | 
 45 | /*
 46 |  * Base for filters designed via algorithmic placement of poles and zeros.
 47 |  *
 48 |  * Typically, the filter is first designed as a half-band low pass or
 49 |  * low shelf analog filter (s-plane). Then, using a transformation such
 50 |  * as the ones from Constantinides, the poles and zeros of the analog filter
 51 |  * are calculated in the z-plane.
 52 |  *
 53 |  */
 54 | 
 55 | // Factored implementations to reduce template instantiations
 56 | 
 57 | class PoleFilterBase2 : public Cascade
 58 | {
 59 | public:
 60 |   // This gets the poles/zeros directly from the digital
 61 |   // prototype. It is used to double check the correctness
 62 |   // of the recovery of pole/zeros from biquad coefficients.
 63 |   //
 64 |   // It can also be used to accelerate the interpolation
 65 |   // of pole/zeros for parameter modulation, since a pole
 66 |   // filter already has them calculated
 67 | 
 68 | #if 1
 69 |   // Commenting this out will pass the call to the Cascade,
 70 |   // which tries to compute the poles and zeros from the biquad
 71 |   // coefficients.
 72 |   std::vector<PoleZeroPair> getPoleZeros () const
 73 |   {
 74 |     std::vector<PoleZeroPair> vpz;
 75 |     const int pairs = (m_digitalProto.getNumPoles () + 1) / 2;
 76 |     for (int i = 0; i < pairs; ++i)
 77 |       vpz.push_back (m_digitalProto[i]);
 78 |     return vpz;
 79 |   }
 80 | #endif
 81 | 
 82 | protected:
 83 |   LayoutBase m_digitalProto;
 84 | };
 85 | 
 86 | // Serves a container to hold the analog prototype
 87 | // and the digital pole/zero layout.
 88 | template <class AnalogPrototype>
 89 | class PoleFilterBase : public PoleFilterBase2
 90 | {
 91 | protected:
 92 |   void setPrototypeStorage (const LayoutBase& analogStorage,
 93 |                             const LayoutBase& digitalStorage)
 94 |   {
 95 |     m_analogProto.setStorage (analogStorage);
 96 |     m_digitalProto = digitalStorage;
 97 |   }
 98 | 
 99 | protected:
100 |   AnalogPrototype m_analogProto;
101 | };
102 | 
103 | //------------------------------------------------------------------------------
104 | 
105 | // Storage for pole filters
106 | template <class BaseClass,
107 |           int MaxAnalogPoles,
108 |           int MaxDigitalPoles = MaxAnalogPoles>
109 | struct PoleFilter : BaseClass
110 |                   , CascadeStages <(MaxDigitalPoles + 1) / 2>
111 | {
112 |   PoleFilter ()
113 |   {
114 |     // This glues together the factored base classes
115 |     // with the templatized storage classes.
116 |     BaseClass::setCascadeStorage (this->getCascadeStorage());
117 |     BaseClass::setPrototypeStorage (m_analogStorage, m_digitalStorage);
118 |   }
119 | 
120 | private:
121 |   Layout <MaxAnalogPoles> m_analogStorage;
122 |   Layout <MaxDigitalPoles> m_digitalStorage;
123 | };
124 | 
125 | //------------------------------------------------------------------------------
126 | 
127 | /*
128 |  * s-plane to z-plane transforms
129 |  *
130 |  * For pole filters, an analog prototype is created via placement of
131 |  * poles and zeros in the s-plane. The analog prototype is either
132 |  * a halfband low pass or a halfband low shelf. The poles, zeros,
133 |  * and normalization parameters are transformed into the z-plane
134 |  * using variants of the bilinear transformation.
135 |  *
136 |  */
137 | 
138 | // low pass to low pass 
139 | class LowPassTransform
140 | {
141 | public:
142 |   LowPassTransform (double fc,
143 |                     LayoutBase& digital,
144 |                     LayoutBase const& analog);
145 | 
146 | private:
147 |   complex_t transform (complex_t c);
148 | 
149 |   double f;
150 | };
151 | 
152 | //------------------------------------------------------------------------------
153 | 
154 | // low pass to high pass
155 | class HighPassTransform
156 | {
157 | public:
158 |   HighPassTransform (double fc,
159 |                      LayoutBase& digital,
160 |                      LayoutBase const& analog);
161 | 
162 | private:
163 |   complex_t transform (complex_t c);
164 | 
165 |   double f;
166 | };
167 | 
168 | //------------------------------------------------------------------------------
169 | 
170 | // low pass to band pass transform
171 | class BandPassTransform
172 | {
173 | 
174 | public:
175 |   BandPassTransform (double fc,
176 |                      double fw,
177 |                      LayoutBase& digital,
178 |                      LayoutBase const& analog);
179 | 
180 | private:
181 |   ComplexPair transform (complex_t c);
182 | 
183 |   double wc;
184 |   double wc2;
185 |   double a;
186 |   double b;
187 |   double a2;
188 |   double b2;
189 |   double ab;
190 |   double ab_2;
191 | };
192 | 
193 | //------------------------------------------------------------------------------
194 | 
195 | // low pass to band stop transform
196 | class BandStopTransform
197 | {
198 | public:
199 |   BandStopTransform (double fc,
200 |                      double fw,
201 |                      LayoutBase& digital,
202 |                      LayoutBase const& analog);
203 | 
204 | private:
205 |   ComplexPair transform (complex_t c);
206 | 
207 |   double wc;
208 |   double wc2;
209 |   double a;
210 |   double b;
211 |   double a2;
212 |   double b2;
213 | };
214 | 
215 | }
216 | 
217 | #endif
218 | 


--------------------------------------------------------------------------------
/src/DspFilters/RBJ.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/RBJ.h"
 38 | 
 39 | namespace Dsp {
 40 | 
 41 | namespace RBJ {
 42 | 
 43 | void LowPass::setup (double sampleRate,
 44 |                      double cutoffFrequency,
 45 |                      double q)
 46 | {
 47 |   double w0 = 2 * doublePi * cutoffFrequency / sampleRate;
 48 |   double cs = cos (w0);
 49 |   double sn = sin (w0);
 50 |   double AL = sn / (2 * q);
 51 |   double b0 = (1 - cs) / 2;
 52 |   double b1 =  1 - cs;
 53 |   double b2 = (1 - cs) / 2;
 54 |   double a0 =  1 + AL;
 55 |   double a1 = -2 * cs;
 56 |   double a2 =  1 - AL;
 57 |   setCoefficients (a0, a1, a2, b0, b1, b2);
 58 | }
 59 | 
 60 | void HighPass::setup (double sampleRate,
 61 |                       double cutoffFrequency,
 62 |                       double q)
 63 | {
 64 |   double w0 = 2 * doublePi * cutoffFrequency / sampleRate;
 65 |   double cs = cos (w0);
 66 |   double sn = sin (w0);
 67 |   double AL = sn / ( 2 * q );
 68 |   double b0 =  (1 + cs) / 2;
 69 |   double b1 = -(1 + cs);
 70 |   double b2 =  (1 + cs) / 2;
 71 |   double a0 =  1 + AL;
 72 |   double a1 = -2 * cs;
 73 |   double a2 =  1 - AL;
 74 |   setCoefficients (a0, a1, a2, b0, b1, b2);
 75 | }
 76 | 
 77 | void BandPass1::setup (double sampleRate,
 78 |                        double centerFrequency,
 79 |                        double bandWidth)
 80 | {
 81 |   double w0 = 2 * doublePi * centerFrequency / sampleRate;
 82 |   double cs = cos (w0);
 83 |   double sn = sin (w0);
 84 |   double AL = sn / ( 2 * bandWidth );
 85 |   double b0 = bandWidth * AL;// sn / 2;
 86 |   double b1 =  0;
 87 |   double b2 = -bandWidth * AL;//-sn / 2;
 88 |   double a0 =  1 + AL;
 89 |   double a1 = -2 * cs;
 90 |   double a2 =  1 - AL;
 91 |   setCoefficients (a0, a1, a2, b0, b1, b2);
 92 | }
 93 | 
 94 | void BandPass2::setup (double sampleRate,
 95 |                        double centerFrequency,
 96 |                        double bandWidth)
 97 | {
 98 |   double w0 = 2 * doublePi * centerFrequency / sampleRate;
 99 |   double cs = cos (w0);
100 |   double sn = sin (w0);
101 |   double AL = sn / ( 2 * bandWidth );
102 |   double b0 =  AL;
103 |   double b1 =  0;
104 |   double b2 = -AL;
105 |   double a0 =  1 + AL;
106 |   double a1 = -2 * cs;
107 |   double a2 =  1 - AL;
108 |   setCoefficients (a0, a1, a2, b0, b1, b2);
109 | }
110 | 
111 | void BandStop::setup (double sampleRate,
112 |                       double centerFrequency,
113 |                       double bandWidth)
114 | {
115 |   double w0 = 2 * doublePi * centerFrequency / sampleRate;
116 |   double cs = cos (w0);
117 |   double sn = sin (w0);
118 |   double AL = sn / ( 2 * bandWidth );
119 |   double b0 =  1;
120 |   double b1 = -2 * cs;
121 |   double b2 =  1;
122 |   double a0 =  1 + AL;
123 |   double a1 = -2 * cs;
124 |   double a2 =  1 - AL;
125 |   setCoefficients (a0, a1, a2, b0, b1, b2);
126 | }
127 | 
128 | void LowShelf::setup (double sampleRate,
129 |                       double cutoffFrequency,
130 |                       double gainDb,
131 |                       double shelfSlope)
132 | {
133 |   double A  = pow (10, gainDb/40);
134 |   double w0 = 2 * doublePi * cutoffFrequency / sampleRate;
135 |   double cs = cos (w0);
136 |   double sn = sin (w0);
137 |   double AL = sn / 2 * ::std::sqrt ((A + 1/A) * (1/shelfSlope - 1) + 2);
138 |   double sq = 2 * sqrt(A) * AL;
139 |   double b0 =    A*( (A+1) - (A-1)*cs + sq );
140 |   double b1 =  2*A*( (A-1) - (A+1)*cs );
141 |   double b2 =    A*( (A+1) - (A-1)*cs - sq );
142 |   double a0 =        (A+1) + (A-1)*cs + sq;
143 |   double a1 =   -2*( (A-1) + (A+1)*cs );
144 |   double a2 =        (A+1) + (A-1)*cs - sq;
145 |   setCoefficients (a0, a1, a2, b0, b1, b2);
146 | }
147 | 
148 | void HighShelf::setup (double sampleRate,
149 |                        double cutoffFrequency,
150 |                        double gainDb,
151 |                        double shelfSlope)
152 | {
153 |   double A  = pow (10, gainDb/40);
154 |   double w0 = 2 * doublePi * cutoffFrequency / sampleRate;
155 |   double cs = cos (w0);
156 |   double sn = sin (w0);
157 |   double AL = sn / 2 * ::std::sqrt ((A + 1/A) * (1/shelfSlope - 1) + 2);
158 |   double sq = 2 * sqrt(A) * AL;
159 |   double b0 =    A*( (A+1) - (A-1)*cs + sq );
160 |   double b1 = -2*A*( (A-1) - (A+1)*cs );
161 |   double b2 =    A*( (A+1) - (A-1)*cs - sq );
162 |   double a0 =        (A+1) + (A-1)*cs + sq;
163 |   double a1 =    2*( (A-1) + (A+1)*cs );
164 |   double a2 =        (A+1) + (A-1)*cs - sq;
165 |   setCoefficients (a0, a1, a2, b0, b1, b2);
166 | }
167 | 
168 | void BandShelf::setup (double sampleRate,
169 |                        double centerFrequency,
170 |                        double gainDb,
171 |                        double bandWidth)
172 | {
173 |   double A  = pow (10, gainDb/40);
174 |   double w0 = 2 * doublePi * centerFrequency / sampleRate;
175 |   double cs = cos(w0);
176 |   double sn = sin(w0);
177 |   double AL = sn * sinh( doubleLn2/2 * bandWidth * w0/sn );
178 |   assert (!Dsp::is_nan (AL));
179 |   double b0 =  1 + AL * A;
180 |   double b1 = -2 * cs;
181 |   double b2 =  1 - AL * A;
182 |   double a0 =  1 + AL / A;
183 |   double a1 = -2 * cs;
184 |   double a2 =  1 - AL / A;
185 |   setCoefficients (a0, a1, a2, b0, b1, b2);
186 | }
187 | 
188 | void AllPass::setup (double sampleRate,
189 |                      double phaseFrequency,
190 |                      double q)
191 | {
192 |   double w0 = 2 * doublePi * phaseFrequency / sampleRate;
193 |   double cs = cos (w0);
194 |   double sn = sin (w0);
195 |   double AL = sn / ( 2 * q );
196 |   double b0 =  1 - AL;
197 |   double b1 = -2 * cs;
198 |   double b2 =  1 + AL;
199 |   double a0 =  1 + AL;
200 |   double a1 = -2 * cs;
201 |   double a2 =  1 - AL;
202 |   setCoefficients (a0, a1, a2, b0, b1, b2);
203 | }
204 | 
205 | }
206 | 
207 | }
208 | 


--------------------------------------------------------------------------------
/src/DspFilters/RBJ.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_RBJ_H
 37 | #define DSPFILTERS_RBJ_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Biquad.h"
 41 | #include "DspFilters/Design.h"
 42 | #include "DspFilters/Filter.h"
 43 | 
 44 | namespace Dsp {
 45 | 
 46 | /*
 47 |  * Filter realizations based on Robert Bristol-Johnson formulae:
 48 |  *
 49 |  * http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
 50 |  *
 51 |  */
 52 | 
 53 | namespace RBJ {
 54 | 
 55 | //
 56 | // Raw filters
 57 | //
 58 | 
 59 | struct LowPass : BiquadBase
 60 | {
 61 |   void setup (double sampleRate,
 62 |               double cutoffFrequency,
 63 |               double q);
 64 | };
 65 | 
 66 | struct HighPass : BiquadBase
 67 | {
 68 |   void setup (double sampleRate,
 69 |               double cutoffFrequency,
 70 |               double q);
 71 | };
 72 | 
 73 | struct BandPass1 : BiquadBase
 74 | {
 75 |   // (constant skirt gain, peak gain = Q)
 76 |   void setup (double sampleRate,
 77 |               double centerFrequency,
 78 |               double bandWidth);
 79 | };
 80 | 
 81 | struct BandPass2 : BiquadBase
 82 | {
 83 |   // (constant 0 dB peak gain)
 84 |   void setup (double sampleRate,
 85 |               double centerFrequency,
 86 |               double bandWidth);
 87 | };
 88 | 
 89 | struct BandStop : BiquadBase
 90 | {
 91 |   void setup (double sampleRate,
 92 |               double centerFrequency,
 93 |               double bandWidth);
 94 | };
 95 | 
 96 | struct LowShelf : BiquadBase
 97 | {
 98 |   void setup (double sampleRate,
 99 |               double cutoffFrequency,
100 |               double gainDb,
101 |               double shelfSlope);
102 | };
103 | 
104 | struct HighShelf : BiquadBase
105 | {
106 |   void setup (double sampleRate,
107 |               double cutoffFrequency,
108 |               double gainDb,
109 |               double shelfSlope);
110 | };
111 | 
112 | struct BandShelf : BiquadBase
113 | {
114 |   void setup (double sampleRate,
115 |               double centerFrequency,
116 |               double gainDb,
117 |               double bandWidth);
118 | };
119 | 
120 | struct AllPass : BiquadBase
121 | {
122 |   void setup (double sampleRate,
123 |               double phaseFrequency,
124 |               double q);
125 | };
126 | 
127 | //------------------------------------------------------------------------------
128 | 
129 | //
130 | // Gui-friendly Design layer
131 | //
132 | 
133 | namespace Design {
134 | 
135 | struct TypeIBase : DesignBase
136 | {
137 |   enum
138 |   {
139 |     NumParams = 3
140 |   };
141 | 
142 |   static int getNumParams ()
143 |   {
144 |     return 3;
145 |   }
146 | 
147 |   static const ParamInfo getParamInfo_1 ()
148 |   {
149 |     return ParamInfo::defaultCutoffFrequencyParam ();
150 |   }
151 | 
152 |   static const ParamInfo getParamInfo_2 ()
153 |   {
154 |     return ParamInfo::defaultQParam ();
155 |   }
156 | };
157 | 
158 | template <class FilterClass>
159 | struct TypeI : TypeIBase, FilterClass
160 | {
161 |   void setParams (const Params& params)
162 |   {
163 |     FilterClass::setup (params[0], params[1], params[2]);
164 |   }
165 | };
166 | 
167 | struct TypeIIBase : DesignBase
168 | {
169 |   enum
170 |   {
171 |     NumParams = 3
172 |   };
173 | 
174 |   static int getNumParams ()
175 |   {
176 |     return 3;
177 |   }
178 | 
179 |   static const ParamInfo getParamInfo_1 ()
180 |   {
181 |     return ParamInfo::defaultCenterFrequencyParam ();
182 |   }
183 | 
184 |   static const ParamInfo getParamInfo_2 ()
185 |   {
186 |     return ParamInfo::defaultBandwidthParam ();
187 |   }
188 | };
189 | 
190 | template <class FilterClass>
191 | struct TypeII : TypeIIBase, FilterClass
192 | {
193 |   void setParams (const Params& params)
194 |   {
195 |     FilterClass::setup (params[0], params[1], params[2]);
196 |   }
197 | };
198 | 
199 | struct TypeIIIBase : DesignBase
200 | {
201 |   enum
202 |   {
203 |     NumParams = 4
204 |   };
205 | 
206 |   static int getNumParams ()
207 |   {
208 |     return 4;
209 |   }
210 | 
211 |   static const ParamInfo getParamInfo_1 ()
212 |   {
213 |     return ParamInfo::defaultCutoffFrequencyParam ();
214 |   }
215 | 
216 |   static const ParamInfo getParamInfo_2 ()
217 |   {
218 |     return ParamInfo::defaultGainParam ();
219 |   }
220 | 
221 |   static const ParamInfo getParamInfo_3 ()
222 |   {
223 |     return ParamInfo::defaultSlopeParam ();
224 |   }
225 | };
226 | 
227 | template <class FilterClass>
228 | struct TypeIII : TypeIIIBase, FilterClass
229 | {
230 |   void setParams (const Params& params)
231 |   {
232 |     FilterClass::setup (params[0], params[1], params[2], params[3]);
233 |   }
234 | };
235 | 
236 | struct TypeIVBase : DesignBase
237 | {
238 |   enum
239 |   {
240 |     NumParams = 4
241 |   };
242 | 
243 |   static int getNumParams ()
244 |   {
245 |     return 4;
246 |   }
247 | 
248 |   static const ParamInfo getParamInfo_1 ()
249 |   {
250 |     return ParamInfo::defaultCenterFrequencyParam ();
251 |   }
252 | 
253 |   static const ParamInfo getParamInfo_2 ()
254 |   {
255 |     return ParamInfo::defaultGainParam ();
256 |   }
257 | 
258 |   static const ParamInfo getParamInfo_3 ()
259 |   {
260 |     return ParamInfo::defaultBandwidthParam ();
261 |   }
262 | };
263 | 
264 | template <class FilterClass>
265 | struct TypeIV : TypeIVBase , FilterClass
266 | {
267 |   void setParams (const Params& params)
268 |   {
269 |     FilterClass::setup (params[0], params[1], params[2], params[3]);
270 |   }
271 | };
272 | 
273 | //------------------------------------------------------------------------------
274 | 
275 | struct LowPass : TypeI <RBJ::LowPass>
276 | {
277 |   static Kind getKind () { return kindLowPass; }
278 |   static const char* getName() { return "RBJ Low Pass"; }
279 | };
280 | 
281 | struct HighPass : TypeI <RBJ::HighPass>
282 | {
283 |   static Kind getKind () { return kindHighPass; }
284 |   static const char* getName() { return "RBJ High Pass"; }
285 | };
286 | 
287 | struct BandPass1 : TypeII <RBJ::BandPass1>
288 | {
289 |   static Kind getKind () { return kindBandPass; }
290 |   static const char* getName() { return "RBJ Band Pass 1"; }
291 | };
292 | 
293 | struct BandPass2 : TypeII <RBJ::BandPass2>
294 | {
295 |   static Kind getKind () { return kindBandPass; }
296 |   static const char* getName() { return "RBJ Band Pass 2"; }
297 | };
298 | 
299 | struct BandStop : TypeII <RBJ::BandStop>
300 | {
301 |   static Kind getKind () { return kindBandStop; }
302 |   static const char* getName() { return "RBJ Band Stop"; }
303 | };
304 | 
305 | struct LowShelf : TypeIII <RBJ::LowShelf>
306 | {
307 |   static Kind getKind () { return kindLowShelf; }
308 |   static const char* getName() { return "RBJ Low Shelf"; }
309 | };
310 | 
311 | struct HighShelf : TypeIII <RBJ::HighShelf>
312 | {
313 |   static Kind getKind () { return kindHighShelf; }
314 |   static const char* getName() { return "RBJ High Shelf"; }
315 | };
316 | 
317 | struct BandShelf : TypeIV <RBJ::BandShelf>
318 | {
319 |   static Kind getKind () { return kindBandShelf; }
320 |   static const char* getName() { return "RBJ Band Shelf"; }
321 | };
322 | 
323 | struct AllPass : TypeI <RBJ::AllPass>
324 | {
325 |   static Kind getKind () { return kindOther; }
326 |   static const char* getName() { return "RBJ All Pass"; }
327 | };
328 | 
329 | }
330 | 
331 | }
332 | 
333 | }
334 | 
335 | #endif
336 | 


--------------------------------------------------------------------------------
/src/DspFilters/RootFinder.cpp:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #include "DspFilters/Common.h"
 37 | #include "DspFilters/RootFinder.h"
 38 | #include <stdexcept>
 39 | 
 40 | namespace Dsp {
 41 | 
 42 | void RootFinderBase::solve (int degree,
 43 |                             bool polish,
 44 |                             bool doSort)
 45 | {
 46 |   assert (degree <= m_maxdegree);
 47 | 
 48 |   const double EPS = 1.0e-30;
 49 | 
 50 |   int its;
 51 |   complex_t x, b, c;
 52 | 
 53 |   int m = degree;
 54 | 
 55 |   // copy coefficients
 56 |   for (int j = 0; j <= m; ++j)
 57 |     m_ad[j] = m_a[j];
 58 | 
 59 |   // for each root
 60 |   for (int j = m - 1; j >= 0; --j)
 61 |   {
 62 |     // initial guess at 0
 63 |     x = 0.0;
 64 |     laguerre (j + 1, m_ad, x, its);
 65 |     
 66 |     if (fabs (std::imag(x)) <= 2.0 * EPS * fabs (std::real(x)))
 67 |       x = complex_t (std::real(x), 0.0);
 68 | 
 69 |     m_root[j] = x;
 70 | 
 71 |     // deflate
 72 |     b = m_ad[j+1];
 73 |     for (int jj = j; jj >= 0; --jj)
 74 |     {
 75 |       c = m_ad[jj];
 76 |       m_ad[jj] = b;
 77 |       b = x * b + c;
 78 |     }
 79 |   }
 80 | 
 81 |   if (polish)
 82 |     for (int j = 0; j < m; ++j)
 83 |       laguerre (degree, m_a, m_root[j], its);
 84 | 
 85 |   if (doSort)
 86 |     sort (degree);
 87 | }
 88 | 
 89 | void RootFinderBase::sort (int degree)
 90 | {
 91 |   for (int j = 1; j < degree; ++j)
 92 |   {
 93 |     complex_t x = m_root[j];
 94 | 
 95 |     int i;
 96 |     for (i = j - 1; i >= 0; --i )
 97 |     {
 98 |       if (m_root[i].imag() >= x.imag())
 99 |         break;
100 | 
101 |       m_root[i+1] = m_root[i];
102 |     }
103 | 
104 |     m_root[i+1] = x;
105 |   }
106 | }
107 | 
108 | //------------------------------------------------------------------------------
109 | 
110 | void RootFinderBase::laguerre (int degree,
111 |                            complex_t a[],
112 |                            complex_t& x,
113 |                            int& its)
114 | {
115 |   const int MR = 8, MT = 10, MAXIT = MT * MR;
116 |   const double EPS = std::numeric_limits<double>::epsilon();
117 | 
118 |   static const double frac[MR + 1] =
119 |     {0.0, 0.5, 0.25, 0.75, 0.13, 0.38, 0.62, 0.88, 1.0};
120 | 
121 |   complex_t dx, x1, b, d, f, g, h, sq, gp, gm, g2;
122 | 
123 |   int m = degree;
124 |   for (int iter = 1; iter <= MAXIT; ++iter)
125 |   {
126 |     its = iter;
127 |     b = a[m];
128 |     double err = std::abs(b);
129 |     d = f = 0.0;
130 |     double abx = std::abs(x);
131 |     for (int j = m - 1; j >= 0; --j)
132 |     {
133 |       f = x * f + d;
134 |       d = x * d + b;
135 |       b = x * b + a[j];
136 |       err = std::abs(b) + abx * err;
137 |     }
138 |     err *= EPS;
139 |     if (std::abs(b) <= err)
140 |       return;
141 |     g  = d / b;
142 |     g2 = g * g;
143 |     h  = g2 - 2.0 * f / b;
144 |     
145 |     sq = sqrt (double(m - 1) * (double(m) * h - g2));
146 |     gp = g + sq;
147 |     gm = g - sq;
148 |     
149 |     double abp = std::abs (gp);
150 |     double abm = std::abs (gm);
151 |     if (abp < abm)
152 |       gp = gm;
153 |     dx = std::max(abp, abm) > 0.0 ? double(m) / gp : std::polar (1 + abx, double(iter));
154 |     x1 = x - dx;
155 |     if (x == x1)
156 |       return;
157 |     if (iter % MT != 0)
158 |       x = x1;
159 |     else
160 |       x -= frac[iter / MT] * dx;
161 |   }
162 | 
163 |   throw std::logic_error ("laguerre failed");
164 | }
165 | 
166 | //------------------------------------------------------------------------------
167 | 
168 | complex_t RootFinderBase::eval (int degree,
169 |                             const complex_t& x )
170 | {
171 |   complex_t y;
172 | 
173 |   if (x != 0.)
174 |   {
175 |     for (int i = 0; i <= degree; ++i)
176 |       y += m_a[i] * pow (x, double(i));
177 |   }
178 |   else
179 |   {
180 |     y = m_a[0];
181 |   }
182 | 
183 |   return y;
184 | }
185 | 
186 | 
187 | }
188 | 


--------------------------------------------------------------------------------
/src/DspFilters/RootFinder.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_ROOTFINDER_H
 37 | #define DSPFILTERS_ROOTFINDER_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Types.h"
 41 | 
 42 | namespace Dsp {
 43 | 
 44 | //
 45 | // Finds the complex roots of the given polynomial with
 46 | // complex-valued coefficients using a numerical method.
 47 | //
 48 | 
 49 | class RootFinderBase
 50 | {
 51 | public:
 52 |   struct Array
 53 |   {
 54 |     Array (int max, complex_t* values)
 55 |      // : m_max (max)
 56 |      // , m_values (values)
 57 |     {
 58 |     }
 59 | 
 60 |     //complex_t& operator[] (int index)
 61 |     //{
 62 |     //};
 63 |   };
 64 | 
 65 |   //
 66 |   // Find roots of polynomial f(x)=a[0]+a[1]*x+a[2]*x^2...+a[degree]*x^degree
 67 |   // The input coefficients are set using coef()[].
 68 |   // The solutions are placed in roots.
 69 |   //
 70 |   void solve (int degree,
 71 |               bool polish = true,
 72 |               bool doSort = true);
 73 | 
 74 |   // Evaluates the polynomial at x
 75 |   complex_t eval (int degree,
 76 |                   const complex_t& x);
 77 | 
 78 |   // Direct access to the input coefficient array of size degree+1.
 79 |   complex_t* coef()
 80 |   {
 81 |     return m_a;
 82 |   }
 83 | 
 84 |   // Direct access to the resulting roots array of size degree
 85 |   complex_t* root()
 86 |   {
 87 |     return m_root;
 88 |   }
 89 | 
 90 |   // sort the roots by descending imaginary part
 91 |   void sort (int degree);
 92 | 
 93 | private:
 94 |   // Improves x as a root using Laguerre's method.
 95 |   // The input coefficient array has degree+1 elements.
 96 |   void laguerre (int degree,
 97 |                  complex_t a[],
 98 |                  complex_t& x,
 99 |                  int& its);
100 | 
101 | protected:
102 |   int m_maxdegree;
103 |   complex_t* m_a;		// input coefficients (m_maxdegree+1 elements)
104 |   complex_t* m_ad;	// copy of deflating coefficients
105 |   complex_t* m_root; // array of roots (maxdegree elements)
106 | };
107 | 
108 | //------------------------------------------------------------------------------
109 | 
110 | template<int maxdegree>
111 | struct RootFinder : RootFinderBase
112 | {
113 |   RootFinder()
114 |   {
115 |     m_maxdegree = maxdegree;
116 |     m_a  = m_a0;
117 |     m_ad = m_ad0;
118 |     m_root = m_r;
119 |   }
120 | 
121 | private:
122 |   complex_t m_a0 [maxdegree+1];
123 |   complex_t m_ad0[maxdegree+1];
124 |   complex_t m_r  [maxdegree];
125 | };
126 | 
127 | }
128 | 
129 | #endif
130 | 


--------------------------------------------------------------------------------
/src/DspFilters/SmoothedFilter.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_SMOOTHEDFILTER_H
 37 | #define DSPFILTERS_SMOOTHEDFILTER_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Filter.h"
 41 | 
 42 | namespace Dsp {
 43 | 
 44 | /*
 45 |  * Implements smooth modulation of time-varying filter parameters
 46 |  *
 47 |  */
 48 | template <class DesignClass,
 49 |           int Channels,
 50 |           class StateType = DirectFormII>
 51 | class SmoothedFilterDesign
 52 |   : public FilterDesign <DesignClass,
 53 |                        Channels,
 54 |                        StateType>
 55 | {
 56 | public:
 57 |   typedef FilterDesign <DesignClass, Channels, StateType> filter_type_t;
 58 | 
 59 |   SmoothedFilterDesign (int transitionSamples)
 60 |     : m_transitionSamples (transitionSamples)
 61 |     , m_remainingSamples (-1) // first time flag
 62 |   {
 63 |   }
 64 | 
 65 |   // Process a block of samples.
 66 |   template <typename Sample>
 67 |   void processBlock (int numSamples,
 68 |                      Sample* const* destChannelArray)
 69 |   {
 70 |     const int numChannels = this->getNumChannels();
 71 | 
 72 |     // If this goes off it means setup() was never called
 73 |     assert (m_remainingSamples >= 0);
 74 | 
 75 |     // first handle any transition samples
 76 |     int remainingSamples = std::min (m_remainingSamples, numSamples);
 77 | 
 78 |     if (remainingSamples > 0)
 79 |     {
 80 |       // interpolate parameters for each sample
 81 |       const double t = 1. / m_remainingSamples;
 82 |       double dp[maxParameters];
 83 |       for (int i = 0; i < DesignClass::NumParams; ++i)
 84 |         dp[i] = (this->getParams()[i] - m_transitionParams[i]) * t;
 85 | 
 86 |       for (int n = 0; n < remainingSamples; ++n)
 87 |       {
 88 |         for (int i = DesignClass::NumParams; --i >=0;)
 89 |           m_transitionParams[i] += dp[i];
 90 | 
 91 |         m_transitionFilter.setParams (m_transitionParams);
 92 |         
 93 |         for (int i = numChannels; --i >= 0;)
 94 |         {
 95 |           Sample* dest = destChannelArray[i]+n;
 96 |           *dest = this->m_state[i].process (*dest, m_transitionFilter);
 97 |         }
 98 |       }
 99 | 
100 |       m_remainingSamples -= remainingSamples;
101 | 
102 |       if (m_remainingSamples == 0)
103 |         m_transitionParams = this->getParams();
104 |     }
105 | 
106 |     // do what's left
107 |     if (numSamples - remainingSamples > 0)
108 |     {
109 |       // no transition
110 |       for (int i = 0; i < numChannels; ++i)
111 |         this->m_design.process (numSamples - remainingSamples,
112 |                           destChannelArray[i] + remainingSamples,
113 |                           this->m_state[i]);
114 |     }
115 |   }
116 | 
117 |   void process (int numSamples, float* const* arrayOfChannels)
118 |   {
119 |     processBlock (numSamples, arrayOfChannels);
120 |   }
121 | 
122 |   void process (int numSamples, double* const* arrayOfChannels)
123 |   {
124 |     processBlock (numSamples, arrayOfChannels);
125 |   }
126 | 
127 | protected:
128 |   void doSetParams (const Params& parameters)
129 |   {
130 |     if (m_remainingSamples >= 0)
131 |     {
132 |       m_remainingSamples = m_transitionSamples;
133 |     }
134 |     else
135 |     {
136 |       // first time
137 |       m_remainingSamples = 0;
138 |       m_transitionParams = parameters;
139 |     }
140 | 
141 |     filter_type_t::doSetParams (parameters);
142 |   }
143 | 
144 | protected:
145 |   Params m_transitionParams;
146 |   DesignClass m_transitionFilter;
147 |   int m_transitionSamples;
148 | 
149 |   int m_remainingSamples;        // remaining transition samples
150 | };
151 | 
152 | }
153 | 
154 | #endif
155 | 


--------------------------------------------------------------------------------
/src/DspFilters/State.cpp:
--------------------------------------------------------------------------------
 1 | /*******************************************************************************
 2 | 
 3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
 4 |  By Vinnie Falco
 5 | 
 6 | Official project location:
 7 | https://github.com/vinniefalco/DSPFilters
 8 | 
 9 | See Documentation.cpp for contact information, notes, and bibliography.
10 | 
11 | --------------------------------------------------------------------------------
12 | 
13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
14 | Copyright (c) 2009 by Vinnie Falco
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy
17 | of this software and associated documentation files (the "Software"), to deal
18 | in the Software without restriction, including without limitation the rights
19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
20 | copies of the Software, and to permit persons to whom the Software is
21 | furnished to do so, subject to the following conditions:
22 | 
23 | The above copyright notice and this permission notice shall be included in
24 | all copies or substantial portions of the Software.
25 | 
26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
32 | THE SOFTWARE.
33 | 
34 | *******************************************************************************/
35 | 
36 | #include "DspFilters/Common.h"
37 | #include "DspFilters/State.h"
38 | 
39 | namespace Dsp {
40 | 
41 | //------------------------------------------------------------------------------
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/src/DspFilters/State.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_STATE_H
 37 | #define DSPFILTERS_STATE_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/Biquad.h"
 41 | 
 42 | #include <stdexcept>
 43 | 
 44 | namespace Dsp {
 45 | 
 46 | /*
 47 |  * Various forms of state information required to
 48 |  * process channels of actual sample data.
 49 |  *
 50 |  */
 51 | 
 52 | //------------------------------------------------------------------------------
 53 | 
 54 | /*
 55 |  * State for applying a second order section to a sample using Direct Form I
 56 |  *
 57 |  * Difference equation:
 58 |  *
 59 |  *  y[n] = (b0/a0)*x[n] + (b1/a0)*x[n-1] + (b2/a0)*x[n-2]
 60 |  *                      - (a1/a0)*y[n-1] - (a2/a0)*y[n-2]  
 61 |  */
 62 | class DirectFormI
 63 | {
 64 | public:
 65 |   DirectFormI ()
 66 |   {
 67 |     reset();
 68 |   }
 69 | 
 70 |   void reset ()
 71 |   {
 72 |     m_x1 = 0;
 73 |     m_x2 = 0;
 74 |     m_y1 = 0;
 75 |     m_y2 = 0;
 76 |   }
 77 | 
 78 |   template <typename Sample>
 79 |   inline Sample process1 (const Sample in,
 80 |                           const BiquadBase& s,
 81 |                           const double vsa) // very small amount
 82 |   {
 83 |     double out = s.m_b0*in + s.m_b1*m_x1 + s.m_b2*m_x2
 84 |                            - s.m_a1*m_y1 - s.m_a2*m_y2
 85 |                            + vsa;
 86 |     m_x2 = m_x1;
 87 |     m_y2 = m_y1;
 88 |     m_x1 = in;
 89 |     m_y1 = out;
 90 | 
 91 |     return static_cast<Sample> (out);
 92 |   }
 93 | 
 94 | protected:
 95 |   double m_x2; // x[n-2]
 96 |   double m_y2; // y[n-2]
 97 |   double m_x1; // x[n-1]
 98 |   double m_y1; // y[n-1]
 99 | };
100 | 
101 | //------------------------------------------------------------------------------
102 | 
103 | /*
104 |  * State for applying a second order section to a sample using Direct Form II
105 |  *
106 |  * Difference equation:
107 |  *
108 |  *  v[n] =         x[n] - (a1/a0)*v[n-1] - (a2/a0)*v[n-2]
109 |  *  y(n) = (b0/a0)*v[n] + (b1/a0)*v[n-1] + (b2/a0)*v[n-2]
110 |  *
111 |  */
112 | class DirectFormII
113 | {
114 | public:
115 |   DirectFormII ()
116 |   {
117 |     reset ();
118 |   }
119 | 
120 |   void reset ()
121 |   {
122 |     m_v1 = 0;
123 |     m_v2 = 0;
124 |   }
125 | 
126 |   template <typename Sample>
127 |   Sample process1 (const Sample in,
128 |                    const BiquadBase& s,
129 |                    const double vsa)
130 |   {
131 |     double w   = in - s.m_a1*m_v1 - s.m_a2*m_v2 + vsa;
132 |     double out =      s.m_b0*w    + s.m_b1*m_v1 + s.m_b2*m_v2;
133 | 
134 |     m_v2 = m_v1;
135 |     m_v1 = w;
136 | 
137 |     return static_cast<Sample> (out);
138 |   }
139 | 
140 | private:
141 |   double m_v1; // v[-1]
142 |   double m_v2; // v[-2]
143 | };
144 | 
145 | //------------------------------------------------------------------------------
146 | 
147 | /*
148 |  * Transposed Direct Form I and II
149 |  * by lubomir i. ivanov (neolit123 [at] gmail)
150 |  *
151 |  * Reference:
152 |  * http://www.kvraudio.com/forum/viewtopic.php?p=4430351
153 |  *
154 |  */
155 | 
156 | // I think this one is broken
157 | class TransposedDirectFormI
158 | {
159 | public:
160 |   TransposedDirectFormI ()
161 |   {
162 |     reset ();
163 |   }
164 | 
165 |   void reset ()
166 |   {
167 |     m_v = 0;
168 |     m_s1 = 0;
169 |     m_s1_1 = 0;
170 |     m_s2 = 0;
171 |     m_s2_1 = 0;
172 |     m_s3 = 0;
173 |     m_s3_1 = 0;
174 |     m_s4 = 0;
175 |     m_s4_1 = 0;
176 |   }
177 | 
178 |   template <typename Sample>
179 |   inline Sample process1 (const Sample in,
180 |                           const BiquadBase& s,
181 |                           const double vsa)
182 |   {
183 |     double out;
184 | 
185 |     // can be: in += m_s1_1;
186 |     m_v = in + m_s1_1;
187 |     out = s.m_b0*m_v + m_s3_1;
188 |     m_s1 = m_s2_1 - s.m_a1*m_v;
189 |     m_s2 = -s.m_a2*m_v;
190 |     m_s3 = s.m_b1*m_v + m_s4_1;
191 |     m_s4 = s.m_b2*m_v; 
192 | 
193 |     m_s4_1 = m_s4;
194 |     m_s3_1 = m_s3;
195 |     m_s2_1 = m_s2;
196 |     m_s1_1 = m_s1;
197 | 
198 |     return static_cast<Sample> (out);
199 |   }
200 | 
201 | private:
202 |   double m_v;
203 |   double m_s1;
204 |   double m_s1_1;
205 |   double m_s2;
206 |   double m_s2_1;
207 |   double m_s3;
208 |   double m_s3_1;
209 |   double m_s4;
210 |   double m_s4_1;
211 | };
212 | 
213 | //------------------------------------------------------------------------------
214 | 
215 | class TransposedDirectFormII
216 | {
217 | public:
218 |   TransposedDirectFormII ()
219 |   {
220 |     reset ();
221 |   }
222 | 
223 |   void reset ()
224 |   {
225 |     m_s1 = 0;
226 |     m_s1_1 = 0;
227 |     m_s2 = 0;
228 |     m_s2_1 = 0;
229 |   }
230 | 
231 |   template <typename Sample>
232 |   inline Sample process1 (const Sample in,
233 |                           const BiquadBase& s,
234 |                           const double vsa)
235 |   {
236 |     double out;
237 | 
238 |     out = m_s1_1 + s.m_b0*in + vsa;
239 |     m_s1 = m_s2_1 + s.m_b1*in - s.m_a1*out;
240 |     m_s2 = s.m_b2*in - s.m_a2*out;
241 |     m_s1_1 = m_s1;
242 |     m_s2_1 = m_s2;
243 | 
244 |     return static_cast<Sample> (out);
245 |   }
246 | 
247 | private:
248 |   double m_s1;
249 |   double m_s1_1;
250 |   double m_s2;
251 |   double m_s2_1;
252 | };
253 | 
254 | //------------------------------------------------------------------------------
255 | 
256 | // Holds an array of states suitable for multi-channel processing
257 | template <int Channels, class StateType>
258 | class ChannelsState
259 | {
260 | public:
261 |   ChannelsState ()
262 |   {
263 |   }
264 | 
265 |   const int getNumChannels() const
266 |   {
267 |     return Channels;
268 |   }
269 | 
270 |   void reset ()
271 |   {
272 |     for (int i = 0; i < Channels; ++i)
273 |       m_state[i].reset();
274 |   }
275 | 
276 |   StateType& operator[] (int index)
277 |   {
278 |     assert (index >= 0 && index < Channels);
279 |     return m_state[index];
280 |   }
281 | 
282 |   template <class Filter, typename Sample>
283 |   void process (int numSamples,
284 |                 Sample* const* arrayOfChannels,
285 |                 Filter& filter)
286 |   {
287 |     for (int i = 0; i < Channels; ++i)
288 |       filter.process (numSamples, arrayOfChannels[i], m_state[i]);
289 |   }
290 | 
291 | private:
292 |   StateType m_state[Channels];
293 | };
294 | 
295 | // Empty state, can't process anything
296 | template <class StateType>
297 | class ChannelsState <0, StateType>
298 | {
299 | public:
300 |   const int getNumChannels() const
301 |   {
302 |     return 0;
303 |   }
304 | 
305 |   void reset ()
306 |   {
307 |     throw std::logic_error ("attempt to reset empty ChannelState");
308 |   }
309 | 
310 |   template <class FilterDesign, typename Sample>
311 |   void process (int numSamples,
312 |                 Sample* const* arrayOfChannels,
313 |                 FilterDesign& filter)
314 |   {
315 |     throw std::logic_error ("attempt to process empty ChannelState");
316 |   }
317 | };
318 | 
319 | //------------------------------------------------------------------------------
320 | 
321 | }
322 | 
323 | #endif
324 | 


--------------------------------------------------------------------------------
/src/DspFilters/Types.h:
--------------------------------------------------------------------------------
  1 | /*******************************************************************************
  2 | 
  3 | "A Collection of Useful C++ Classes for Digital Signal Processing"
  4 |  By Vinnie Falco
  5 | 
  6 | Official project location:
  7 | https://github.com/vinniefalco/DSPFilters
  8 | 
  9 | See Documentation.cpp for contact information, notes, and bibliography.
 10 | 
 11 | --------------------------------------------------------------------------------
 12 | 
 13 | License: MIT License (http://www.opensource.org/licenses/mit-license.php)
 14 | Copyright (c) 2009 by Vinnie Falco
 15 | 
 16 | Permission is hereby granted, free of charge, to any person obtaining a copy
 17 | of this software and associated documentation files (the "Software"), to deal
 18 | in the Software without restriction, including without limitation the rights
 19 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 20 | copies of the Software, and to permit persons to whom the Software is
 21 | furnished to do so, subject to the following conditions:
 22 | 
 23 | The above copyright notice and this permission notice shall be included in
 24 | all copies or substantial portions of the Software.
 25 | 
 26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 31 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 32 | THE SOFTWARE.
 33 | 
 34 | *******************************************************************************/
 35 | 
 36 | #ifndef DSPFILTERS_TYPES_H
 37 | #define DSPFILTERS_TYPES_H
 38 | 
 39 | #include "DspFilters/Common.h"
 40 | #include "DspFilters/MathSupplement.h"
 41 | 
 42 | namespace Dsp {
 43 | 
 44 | // A conjugate or real pair
 45 | struct ComplexPair : complex_pair_t
 46 | {
 47 |   ComplexPair ()
 48 |   {
 49 |   }
 50 | 
 51 |   explicit ComplexPair (const complex_t& c1)
 52 |     : complex_pair_t (c1, 0.)
 53 |   {
 54 |     assert (isReal());
 55 |   }
 56 | 
 57 |   ComplexPair (const complex_t& c1,
 58 |                const complex_t& c2)
 59 |     : complex_pair_t (c1, c2)
 60 |   {
 61 |   }
 62 | 
 63 |   bool isConjugate () const
 64 |   {
 65 |     return second == std::conj (first);
 66 |   }
 67 | 
 68 |   bool isReal () const
 69 |   {
 70 |     return first.imag() == 0 && second.imag() == 0;
 71 |   }
 72 | 
 73 |   // Returns true if this is either a conjugate pair,
 74 |   // or a pair of reals where neither is zero.
 75 |   bool isMatchedPair () const
 76 |   {
 77 |     if (first.imag() != 0)
 78 |       return second == std::conj (first);
 79 |     else
 80 |       return second.imag () == 0 &&
 81 |              second.real () != 0 &&
 82 |              first.real () != 0;
 83 |   }
 84 | 
 85 |   bool is_nan () const
 86 |   {
 87 |     return Dsp::is_nan (first) || Dsp::is_nan (second);
 88 |   }
 89 | };
 90 | 
 91 | // A pair of pole/zeros. This fits in a biquad (but is missing the gain)
 92 | struct PoleZeroPair
 93 | {
 94 |   ComplexPair poles;
 95 |   ComplexPair zeros;
 96 | 
 97 |   PoleZeroPair () { }
 98 | 
 99 |   // single pole/zero
100 |   PoleZeroPair (const complex_t& p, const complex_t& z)
101 |     : poles (p), zeros (z)
102 |   {
103 |   }
104 | 
105 |   // pole/zero pair
106 |   PoleZeroPair (const complex_t& p1, const complex_t& z1,
107 |                 const complex_t& p2, const complex_t& z2)
108 |     : poles (p1, p2)
109 |     , zeros (z1, z2)
110 |   {
111 |   }
112 | 
113 |   bool isSinglePole () const
114 |   {
115 |     return poles.second == 0. && zeros.second == 0.;
116 |   }
117 | 
118 |   bool is_nan () const
119 |   {
120 |     return poles.is_nan() || zeros.is_nan();
121 |   }
122 | };
123 | 
124 | // Identifies the general class of filter
125 | enum Kind
126 | {
127 |   kindLowPass,
128 |   kindHighPass,
129 |   kindBandPass,
130 |   kindBandStop,
131 |   kindLowShelf,
132 |   kindHighShelf,
133 |   kindBandShelf,
134 |   kindOther
135 | };
136 | 
137 | }
138 | 
139 | #endif
140 | 


--------------------------------------------------------------------------------
/src/Encoder.cpp:
--------------------------------------------------------------------------------
  1 | #include "Encoder.hpp"
  2 | #include "SDL.h"
  3 | 
  4 | extern "C" {
  5 | #include <libswscale/swscale.h>
  6 | #include <libavutil/opt.h>
  7 | #include <libavcodec/avcodec.h>
  8 | #include <libavutil/channel_layout.h>
  9 | #include <libavutil/common.h>
 10 | #include <libavutil/imgutils.h>
 11 | #include <libavutil/mathematics.h>
 12 | #include <libavutil/samplefmt.h>
 13 | }
 14 | 
 15 | Encoder::Encoder(int width, int height, int frameRate)
 16 | 	: mWidth(width), mHeight(height), mFrameRate(frameRate), 
 17 | 	mBitRate(8000000), mOutputFile(NULL)
 18 | {
 19 | 	avcodec_register_all();
 20 | }
 21 | 
 22 | 
 23 | Encoder::~Encoder()
 24 | {
 25 | }
 26 | 
 27 | 	
 28 | void Encoder::writeFrame(SDL_Surface *data)
 29 | {
 30 | 	
 31 | 	
 32 | 	uint8_t * inData[1] = { (Uint8*)data->pixels }; // RGB24 have one plane
 33 | 	int inLinesize[1] = { data->pitch }; // RGB stride
 34 | 	
 35 | 	int i, ret, x, y, got_output;
 36 | 	
 37 | 	av_init_packet(&mPacket);
 38 | 
 39 | 	mPacket.data = NULL;    // packet data will be allocated by the encoder
 40 | 	mPacket.size = 0;
 41 | 	sws_scale(mSwsContext, inData, inLinesize, 0, mHeight, mFrame->data, mFrame->linesize);
 42 | 	
 43 | 	mFrame->pts = mFrameNumber;
 44 | 	/* encode the image */
 45 | 	ret = avcodec_encode_video2(mCodecContext, &mPacket, mFrame, &got_output);
 46 | 	if (ret < 0) {
 47 | 		fprintf(stderr, "ERROR: Error encoding frame\n");
 48 | 		exit(1);
 49 | 	}
 50 | 	if (got_output) {
 51 | 		fwrite(mPacket.data, 1, mPacket.size, mOutputFile);
 52 | 		//av_packet_unref(&mPacket);
 53 | 	}
 54 | 	
 55 | 	mFrameNumber++;
 56 | }
 57 | 
 58 | 
 59 | void Encoder::initEncoder(const char *filename)
 60 | {
 61 | 	mFrameNumber = 0;
 62 | 	
 63 | 	mSwsContext = sws_getContext(mWidth, mHeight, AV_PIX_FMT_RGB32, mWidth, mHeight, AV_PIX_FMT_YUV420P, 0, 0, 0, 0);
 64 | 		
 65 |     AVCodec *codec;
 66 |     printf("Encode video file %s\n", filename);
 67 | 	
 68 | 	AVCodecID codec_id = AV_CODEC_ID_H264;
 69 | 	
 70 |     /* find the mpeg1 video encoder */
 71 |     codec = avcodec_find_encoder(codec_id);
 72 |     if (!codec) {
 73 |         fprintf(stderr, "ERROR: Codec not found\n");
 74 |         exit(1);
 75 |     }
 76 |     mCodecContext = avcodec_alloc_context3(codec);
 77 |     if (!mCodecContext) {
 78 |         fprintf(stderr, "ERROR: Could not allocate video codec context\n");
 79 |         exit(1);
 80 |     }
 81 | 	
 82 | 	mCodecContext->bit_rate = mBitRate;
 83 |     /* resolution must be a multiple of two */
 84 |     mCodecContext->width = mWidth;
 85 |     mCodecContext->height = mHeight;
 86 |     /* frames per second */
 87 |     mCodecContext->time_base = (AVRational){1,mFrameRate};
 88 |     mCodecContext->gop_size = 10; /* emit one intra frame every ten frames */
 89 |     mCodecContext->max_b_frames = 1;
 90 |     mCodecContext->pix_fmt = AV_PIX_FMT_YUV420P;
 91 | 	
 92 | 	if (codec_id == AV_CODEC_ID_H264)
 93 |         av_opt_set(mCodecContext->priv_data, "preset", "slow", 0);
 94 |     /* open it */
 95 |     if (avcodec_open2(mCodecContext, codec, NULL) < 0) {
 96 |         fprintf(stderr, "ERROR: Could not open codec\n");
 97 |         exit(1);
 98 |     }
 99 |     mOutputFile = fopen(filename, "wb");
100 |     if (!mOutputFile) {
101 |         fprintf(stderr, "ERROR: Could not open %s\n", filename);
102 |         exit(1);
103 |     }
104 |     mFrame = av_frame_alloc();
105 |     if (!mFrame) {
106 |         fprintf(stderr, "ERROR: Could not allocate video frame\n");
107 |         exit(1);
108 |     }
109 |     mFrame->format = mCodecContext->pix_fmt;
110 |     mFrame->width  = mCodecContext->width;
111 |     mFrame->height = mCodecContext->height;
112 |     /* the image can be allocated by any means and av_image_alloc() is
113 |      * just the most convenient way if av_malloc() is to be used */
114 |     int ret = av_image_alloc(mFrame->data, mFrame->linesize, mCodecContext->width, mCodecContext->height,
115 |                          mCodecContext->pix_fmt, 32);
116 |     if (ret < 0) {
117 |         fprintf(stderr, "ERROR: Could not allocate raw picture buffer\n");
118 |         exit(1);
119 |     }
120 | 	
121 | 	mOutputFile = fopen(filename, "wb");
122 | }
123 | 
124 | 
125 | void Encoder::deinitEncoder()
126 | {
127 | 	int got_output;
128 | 	    /* get the delayed frames */
129 |     for (got_output = 1; got_output; mFrameNumber++) {
130 |         int ret = avcodec_encode_video2(mCodecContext, &mPacket, NULL, &got_output);
131 |         if (ret < 0) {
132 |             fprintf(stderr, "ERROR: Error encoding frame\n");
133 |             exit(1);
134 |         }
135 |         if (got_output) {
136 |             fwrite(mPacket.data, 1, mPacket.size, mOutputFile);
137 |             av_packet_unref(&mPacket);
138 |         }
139 |     }
140 |     
141 | 	avcodec_close(mCodecContext);
142 |     av_free(mCodecContext);
143 |     av_freep(&mFrame->data[0]);
144 |     av_frame_free(&mFrame);
145 | 	
146 | 	sws_freeContext(mSwsContext);
147 | 	
148 | 	if (mOutputFile != NULL)
149 | 		fclose(mOutputFile);
150 | }
151 | 
152 | 
153 | void Encoder::setFramerate(int frameRate)
154 | {
155 | 	mFrameRate = frameRate;
156 | 	
157 | }
158 | 
159 | 
160 | void Encoder::setBitrate(int bitrate)
161 | {
162 | 	mBitRate = bitrate;
163 | }
164 | 


--------------------------------------------------------------------------------
/src/Encoder.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <stdio.h>
 4 | class SDL_Surface;
 5 | class SwsContext;
 6 | 
 7 | extern "C" {
 8 | #include <libavcodec/avcodec.h>
 9 | }
10 | 
11 | class Encoder
12 | {
13 | 	int mWidth, mHeight, mFrameRate, mBitRate;
14 | 	FILE *mOutputFile;
15 | 	AVCodecContext *mCodecContext;
16 | 	AVFrame *mFrame;
17 | 	AVPacket mPacket;
18 | 	int mFrameNumber;
19 | 	struct SwsContext * mSwsContext;
20 | 	
21 | public:
22 | 	Encoder(int width, int height, int frameRate);
23 | 	~Encoder();
24 | 	
25 | 	void setFramerate(int frameRate);
26 | 	void setBitrate(int bitrate);
27 | 	
28 | 	void initEncoder(const char *filename);
29 | 	void deinitEncoder();
30 | 	void writeFrame(SDL_Surface *data);
31 | };
32 | 


--------------------------------------------------------------------------------
/src/Main.cpp:
--------------------------------------------------------------------------------
  1 | #include "Screen.hpp"
  2 | #include "Encoder.hpp"
  3 | #include "SDL.h"
  4 | #include <stdio.h>
  5 | 
  6 | int main(int argc, char **argv)
  7 | {
  8 | 	int width = 1920;
  9 | 	int height = 1080;
 10 | 	int frameRate = 60;
 11 | 	float yScale = 1.0f;
 12 | 	bool filterEnabled = false;
 13 | 	float filterCenterFreq = 400;
 14 | 	float filterBandwidth = 50;
 15 | 	int waveChannel = -1;
 16 | 	char filename[1000] = "Output.h264";
 17 | 
 18 | 	Screen screen(width, height);
 19 | 	Encoder encoder(width, height, frameRate);
 20 | 
 21 | 	for (int i = 1 ; i < argc ; ++i)
 22 | 	{
 23 | 		const char *arg = argv[i];
 24 | 
 25 | 		if (arg[0] != '-')
 26 | 		{
 27 | 			char waveChannelName[50];
 28 | 
 29 | 			if (waveChannel == -1)
 30 | 				strcpy(waveChannelName, "all channels");
 31 | 			else
 32 | 				snprintf(waveChannelName, sizeof(waveChannelName), "channel #%d", waveChannel);
 33 | 
 34 | 			if (filterEnabled)
 35 | 			{
 36 | 				if (screen.addWave(arg, waveChannel, yScale, filterCenterFreq, filterBandwidth))
 37 | 					printf("Added wave %s (%s), scaling by %.1f, filter at %.1f Hz, bandwidth %.1f Hz\n",
 38 | 						arg, waveChannelName, yScale, filterCenterFreq, filterBandwidth);
 39 | 				else
 40 | 					printf("Could not open wave %s.\n", arg);
 41 | 			}
 42 | 			else
 43 | 			{
 44 | 				if (screen.addWave(arg, waveChannel, yScale))
 45 | 					printf("Added wave %s (%s), scaling by %.1f, no filter\n", arg, waveChannelName, yScale);
 46 | 				else
 47 | 					printf("Could not open wave %s.\n", arg);
 48 | 			}
 49 | 
 50 | 			// Reset to default for the next input file
 51 | 			waveChannel = -1;
 52 | 		}
 53 | 		else
 54 | 		{
 55 | 			if (strcmp(arg, "-yscale") == 0 && i < argc - 1)
 56 | 			{
 57 | 				yScale = (atof(argv[i + 1]));
 58 | 				++i;
 59 | 			}
 60 | 			else if (strcmp(arg, "-width") == 0 && i < argc - 1)
 61 | 			{
 62 | 				width = (atoi(argv[i + 1]));
 63 | 				screen.setWidth(width);
 64 | 				++i;
 65 | 			}
 66 | 			else if (strcmp(arg, "-height") == 0 && i < argc - 1)
 67 | 			{
 68 | 				height = atoi(argv[i + 1]);
 69 | 				screen.setWidth(height);
 70 | 				++i;
 71 | 			}
 72 | 			else if (strcmp(arg, "-output") == 0 && i < argc - 1)
 73 | 			{
 74 | 				strncpy(filename, argv[i + 1], sizeof(filename));
 75 | 				++i;
 76 | 			}
 77 | 			else if (strcmp(arg, "-bitrate") == 0 && i < argc - 1)
 78 | 			{
 79 | 				++i;
 80 | 				encoder.setBitrate(atoi(argv[i + 1]));
 81 | 			}
 82 | 			else if (strcmp(arg, "-fps") == 0 && i < argc - 1)
 83 | 			{
 84 | 				frameRate = atoi(argv[i + 1]);
 85 | 				encoder.setFramerate(frameRate);
 86 | 				++i;
 87 | 			}
 88 | 			else if (strcmp(arg, "-filter") == 0 && i < argc - 1)
 89 | 			{
 90 | 				filterEnabled = true;
 91 | 				filterCenterFreq = atof(argv[i + 1]);
 92 | 				++i;
 93 | 			}
 94 | 			else if (strcmp(arg, "-nofilter") == 0)
 95 | 			{
 96 | 				filterEnabled = false;
 97 | 			}
 98 | 			else if (strcmp(arg, "-bandwidth") == 0 && i < argc - 1)
 99 | 			{
100 | 				filterEnabled = true;
101 | 				filterBandwidth = atof(argv[i + 1]);
102 | 				++i;
103 | 			}
104 | 			else if (strcmp(arg, "-channel") == 0 && i < argc - 1)
105 | 			{
106 | 				waveChannel = atoi(argv[i + 1]);
107 | 				++i;
108 | 			}
109 | 			else
110 | 			{
111 | 				if (i >= argc - 1)
112 | 				{
113 | 					fprintf(stderr, "ERROR: Expecting value for '%s'\n", arg);
114 | 				}
115 | 				else
116 | 				{
117 | 					fprintf(stderr, "ERROR: Unknown option '%s'\n", arg);
118 | 				}
119 | 			}
120 | 		}
121 | 	}
122 | 
123 | 	if (screen.getWaveCount() == 0)
124 | 	{
125 | 		fprintf(stderr, "ERROR: No waves specified on command line\n");
126 | 		return 1;
127 | 	}
128 | 
129 | 	SDL_Init(SDL_INIT_VIDEO);
130 | 
131 | 	SDL_Surface *surface = SDL_CreateRGBSurface(0, width, height, 32, 0xff, 0xff00, 0xff0000, 0);
132 | 	SDL_Renderer *renderer = SDL_CreateSoftwareRenderer(surface);
133 | 
134 | 	encoder.initEncoder(filename);
135 | 
136 | 	printf("Rendering %dx%d/%d FPS video to %s\n", width, height, frameRate, filename);
137 | 
138 | 	int frame = 0;
139 | 
140 | 	for (float ms = 0; ms < screen.getLengthMs() ; ms += (float)1000 / frameRate)
141 | 	{
142 | 		if ((frame % 100) == 0)
143 | 			printf("\rRendering frame %d at %d:%02d/%d:%02d", frame, (int)(ms / 1000) / 60, (int)(ms / 1000) % 60, (int)(screen.getLengthMs() / 1000) / 60, (int)(screen.getLengthMs() / 1000) % 60);
144 | 
145 | 		SDL_FillRect(surface, NULL, 0);
146 | 		screen.draw(ms, renderer);
147 | 		encoder.writeFrame(surface);
148 | 
149 | 		++frame;
150 | 	}
151 | 
152 | 	printf("\nDone.\n");
153 | 
154 | 	encoder.deinitEncoder();
155 | 
156 | 	SDL_DestroyRenderer(renderer);
157 | 	SDL_FreeSurface(surface);
158 | 
159 | 	return 0;
160 | }
161 | 


--------------------------------------------------------------------------------
/src/Oscilloscope.cpp:
--------------------------------------------------------------------------------
  1 | #include "Oscilloscope.hpp"
  2 | #include "Wave.hpp"
  3 | #include "SDL.h"
  4 | #include <algorithm>
  5 | 
  6 | Oscilloscope::Oscilloscope(const Wave& wave, int windowSizeMs, float yScale)
  7 | 	: mWave(wave), mResolution(0), mYScale(yScale), mFilterEnabled(false), mFilterCenterFreq(400), mFilterBandwidth(50)
  8 | {
  9 | 	mWindowSize = (float)wave.getSampleRate() * windowSizeMs / 1000;
 10 | 	mResolution = mWindowSize;
 11 | 	mFilterBuffer = new float[mWindowSize * 2];
 12 | }
 13 | 
 14 | 
 15 | Oscilloscope::~Oscilloscope()
 16 | {
 17 | 	delete [] mFilterBuffer;
 18 | }
 19 | 
 20 | 
 21 | void Oscilloscope::draw(int position, SDL_Renderer *renderer, const SDL_Rect& area) 
 22 | {
 23 | 	int maxLookback = mWindowSize;
 24 | 	int lookback = 0;
 25 | 	int bufferPosition = mWindowSize;
 26 | 
 27 | 	if (mFilterEnabled)
 28 | 	{
 29 | 		for (int i = 0 ; i < mWindowSize * 2 ; ++i)
 30 | 			mFilterBuffer[i] = mWave.get(position + i - mResolution / 2);
 31 | 		
 32 | 		mFilter.process(mWindowSize * 2, &mFilterBuffer);
 33 | 		
 34 | 		float orig = mFilterBuffer[mWindowSize];
 35 | 		
 36 | 		while (lookback < maxLookback - 1)
 37 | 		{
 38 | 			if (orig > 0)
 39 | 			{
 40 | 				--position;
 41 | 				--bufferPosition;
 42 | 				if (mFilterBuffer[bufferPosition] < 0)
 43 | 					break;
 44 | 			}
 45 | 			else 	
 46 | 			{
 47 | 				++position;
 48 | 				++bufferPosition;
 49 | 				if (mFilterBuffer[bufferPosition] > 0)
 50 | 					break;
 51 | 			}
 52 | 			
 53 | 			lookback++;
 54 | 		}
 55 | 	}
 56 | 	else
 57 | 	{
 58 | 		int orig = mWave.get(position);
 59 | 		
 60 | 		while (lookback < maxLookback)
 61 | 		{
 62 | 			if (orig > 0)
 63 | 			{
 64 | 				--position;
 65 | 				if (mWave.get(position) < 0)
 66 | 					break;
 67 | 			}
 68 | 			else 	
 69 | 			{
 70 | 				++position;
 71 | 				if (mWave.get(position) > 0)
 72 | 					break;
 73 | 			}
 74 | 			
 75 | 			lookback++;
 76 | 		}
 77 | 	}
 78 | 	
 79 | 	int amp, prevAmp = mWave.get(position - mResolution / 2) * mYScale * (area.h / 2) / 32768 + area.h / 2;
 80 | 	
 81 | 	SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
 82 | 	
 83 | 	for (int x = 0 ; x < area.w ; ++x)
 84 | 	{
 85 | 		//amp = mFilterBuffer[x * mResolution / area.w + bufferPosition - mResolution / 2] * mYScale * (area.h / 2) / 32768 + area.h / 2; 
 86 | 		amp = mWave.get(position - mResolution / 2 + x * mResolution / area.w) * mYScale * (area.h / 2) / 32768 + area.h / 2;
 87 | 		
 88 | 		SDL_Rect rect = {x + area.x, std::min(prevAmp, amp) - 4 + area.y, 2, abs(prevAmp - amp) + 8};
 89 | 		
 90 | 		SDL_RenderFillRect(renderer, &rect);
 91 | 		//SDL_RenderDrawLine(renderer, x - 1 + area.x, prevAmp + area.y, x + area.x, amp + area.y);
 92 | 		
 93 | 		prevAmp = amp;
 94 | 	}
 95 | }
 96 | 
 97 | 
 98 | const Wave& Oscilloscope::getWave() const
 99 | {
100 | 	return mWave;
101 | }
102 | 
103 | 
104 | void Oscilloscope::setFilter(float centerFreq, float bandwidth)
105 | {
106 | 	mFilterEnabled = true;
107 | 	mFilterCenterFreq = centerFreq;
108 | 	mFilterBandwidth = bandwidth;
109 | 	
110 | 	mFilter.setup(3, mWave.getSampleRate(), mFilterCenterFreq, mFilterBandwidth, 1);
111 | }
112 | 	
113 | 


--------------------------------------------------------------------------------
/src/Oscilloscope.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class Wave;
 4 | class SDL_Renderer;
 5 | class SDL_Rect;
 6 | 
 7 | #include "DSPFilters/Filter.h"
 8 | #include "DSPFilters/ChebyshevI.h"
 9 | 
10 | class Oscilloscope
11 | {
12 | 	const Wave& mWave;
13 | 	int mResolution;
14 | 	int mWindowSize;
15 | 	float *mFilterBuffer;
16 | 	float mYScale;
17 | 	bool mFilterEnabled;
18 | 	float mFilterCenterFreq, mFilterBandwidth;
19 | 	Dsp::SimpleFilter<Dsp::ChebyshevI::BandPass<3>,1> mFilter;
20 | 	
21 | public:
22 | 	Oscilloscope(const Wave& wave, int windowSizeMs, float yScale);
23 | 	~Oscilloscope();
24 | 	void setFilter(float centerFreq, float bandwidth);
25 | 	const Wave& getWave() const;
26 | 	void draw(int position, SDL_Renderer *renderer, const SDL_Rect& area);
27 | };
28 | 


--------------------------------------------------------------------------------
/src/Screen.cpp:
--------------------------------------------------------------------------------
 1 | #include "Screen.hpp"
 2 | #include "Wave.hpp"
 3 | #include "Oscilloscope.hpp"
 4 | #include "SDL.h"
 5 | 
 6 | Screen::Screen(int width, int height)
 7 | 	:mMargin(0), mWidth(width), mHeight(height)
 8 | {
 9 | }
10 | 
11 | 
12 | Screen::~Screen()
13 | {
14 | 	for (std::vector<Oscilloscope*>::iterator i = mOscilloscopes.begin() ; i != mOscilloscopes.end() ; ++i)
15 | 		delete *i;
16 | 
17 | 	for (std::vector<Wave*>::iterator i = mWaves.begin() ; i != mWaves.end() ; ++i)
18 | 		delete *i;
19 | }
20 | 
21 | 
22 | bool Screen::addWave(const char *filename, int waveChannel, float yScale, float filterCenterFreq, float filterBandwidth)
23 | {
24 | 	Wave *wave = new Wave();
25 | 	if (wave->load(filename, waveChannel))
26 | 	{
27 | 		mWaves.push_back(wave);
28 | 
29 | 		Oscilloscope *osc = new Oscilloscope(*wave, 100, yScale);
30 | 
31 | 		if (filterCenterFreq >= 0.0f)
32 | 			osc->setFilter(filterCenterFreq, filterBandwidth);
33 | 
34 | 		mOscilloscopes.push_back(osc);
35 | 
36 | 		return true;
37 | 	}
38 | 
39 | 	return false;
40 | }
41 | 
42 | void Screen::setMargin(int margin)
43 | {
44 | 	mMargin = margin;
45 | }
46 | 
47 | 
48 | const float Screen::getLengthMs() const
49 | {
50 | 	float ms = 0;
51 | 	for (std::vector<Oscilloscope*>::const_iterator i = mOscilloscopes.begin() ; i != mOscilloscopes.end() ; ++i)
52 | 	{
53 | 		float l = (*i)->getWave().getLength() / ((*i)->getWave().getSampleRate() / 1000);
54 | 		if (ms < l)
55 | 			ms = l;
56 | 	}
57 | 	return ms;
58 | }
59 | 
60 | 
61 | void Screen::draw(float positionMs, SDL_Renderer *renderer)
62 | {
63 | 	int y = 0;
64 | 
65 | 	for (std::vector<Oscilloscope*>::const_iterator i = mOscilloscopes.begin() ; i != mOscilloscopes.end() ; ++i)
66 | 	{
67 | 		SDL_Rect area = {0, y * mHeight / mOscilloscopes.size(), mWidth, mHeight / mOscilloscopes.size()};
68 | 		(*i)->draw(positionMs * (*i)->getWave().getSampleRate() / 1000, renderer, area);
69 | 		++y;
70 | 	}
71 | }
72 | 
73 | 
74 | void Screen::setWidth(int width)
75 | {
76 | 	mWidth = width;
77 | }
78 | 
79 | 
80 | void Screen::setHeight(int height)
81 | {
82 | 	mWidth = height;
83 | }
84 | 
85 | 
86 | int Screen::getWaveCount() const
87 | {
88 | 	return mWaves.size();
89 | }
90 | 


--------------------------------------------------------------------------------
/src/Screen.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | 
 5 | class Wave;
 6 | class Oscilloscope;
 7 | class SDL_Renderer;
 8 | 
 9 | class Screen
10 | {
11 | 	std::vector<Wave*> mWaves;
12 | 	std::vector<Oscilloscope*> mOscilloscopes;
13 | 	int mMargin;
14 | 	int mWidth, mHeight;
15 | public:
16 | 	Screen(int width, int height);
17 | 	~Screen();
18 | 	bool addWave(const char *filename, int waveChannel, float yScale, float filterCenterFreq = -1, float filterBandwidth = -1);
19 | 	int getWaveCount() const;
20 | 	void setMargin(int margin);
21 | 	void setWidth(int width);
22 | 	void setHeight(int height);
23 | 	const float getLengthMs() const;
24 | 	void draw(float positionMs, SDL_Renderer *renderer);
25 | };
26 | 


--------------------------------------------------------------------------------
/src/Wave.cpp:
--------------------------------------------------------------------------------
  1 | #include "Wave.hpp"
  2 | #include <stdlib.h>
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | 
  6 | enum
  7 | {
  8 | 	WAVE_FORMAT_PCM = 1,
  9 | 	WAVE_FORMAT_FLOAT = 3
 10 | };
 11 | 
 12 | Wave::Wave()
 13 | 	: mSamples(NULL), mLength(0), mSampleRate(44100)
 14 | {
 15 | }
 16 | 
 17 | 
 18 | Wave::~Wave()
 19 | {
 20 | 	if (mSamples != NULL)
 21 | 		delete [] mSamples;
 22 | }
 23 | 
 24 | 
 25 | bool Wave::load(const char *filename, int channel)
 26 | {
 27 | 	FILE *f = fopen(filename, "rb");
 28 | 
 29 | 	if (!f)
 30 | 		return false;
 31 | 
 32 | 	struct {
 33 | 		Chunk c;
 34 | 		char WAVEID[4];
 35 | 	}  __attribute__((__packed__)) RIFF;
 36 | 
 37 | 	struct
 38 | 	{
 39 | 		Chunk c;
 40 | 		short wFormatTag;
 41 | 		short nChannels;
 42 | 		long nSamplesPerSec;
 43 | 		long nAvgBytesPerSec;
 44 | 		short nBlockAlign;
 45 | 		short wBitsPerSample;
 46 | 		/*----*/
 47 | 		short cbSize;
 48 | 		/*----*/
 49 | 		short wValidBitsPerSample;
 50 | 		long dwChannelMask;
 51 | 		char SubFormat[16];
 52 | 	} __attribute__((__packed__)) WAVE;
 53 | 
 54 | 	if (fread(&RIFF, 1 , sizeof(RIFF), f) != sizeof(RIFF) || strncmp(RIFF.c.ckID, "RIFF", 4) != 0 || strncmp(RIFF.WAVEID, "WAVE", 4) != 0)
 55 | 	{
 56 | 		fclose(f);
 57 | 		return false;
 58 | 	}
 59 | 
 60 | 	size_t beginning_of_WAVE = ftell(f);
 61 | 
 62 | 	if (fread(&WAVE, 1 , sizeof(WAVE), f) < 16 || strncmp(WAVE.c.ckID, "fmt ", 4) != 0)
 63 | 	{
 64 | 		fclose(f);
 65 | 		return false;
 66 | 	}
 67 | 
 68 | 	if (WAVE.wFormatTag != WAVE_FORMAT_PCM/* && WAVE.wFormatTag != WAVE_FORMAT_FLOAT*/)
 69 | 	{
 70 | 		fclose(f);
 71 | 		return false;
 72 | 	}
 73 | 
 74 | 	int nChannels = WAVE.nChannels;
 75 | 	int bitsPerSample = WAVE.wBitsPerSample;
 76 | 
 77 | 	if (channel >= nChannels)
 78 | 	{
 79 | 		fclose(f);
 80 | 		return false;
 81 | 	}
 82 | 
 83 | 	fseek(f, beginning_of_WAVE + WAVE.c.cksize + 8, SEEK_SET);
 84 | 
 85 | 	Chunk peek = { "", 0 };
 86 | 
 87 | 	// Find "data" chunk while skipping all other types
 88 | 
 89 | 	do
 90 | 	{
 91 | 		int beginningOfChunk = ftell(f);
 92 | 		if (fread(&peek, 1, sizeof(peek), f) != sizeof(peek))
 93 | 		{
 94 | 			fclose(f);
 95 | 			return false;
 96 | 		}
 97 | 
 98 | 		if (strncmp(peek.ckID, "data", 4) == 0)
 99 | 			break;
100 | 
101 | 		fseek(f, beginningOfChunk + peek.cksize + 8, SEEK_SET);
102 | 	}
103 | 	while (strncmp(peek.ckID, "data", 4) != 0);
104 | 
105 | 	mLength = peek.cksize / (WAVE.wBitsPerSample / 8) / WAVE.nChannels;
106 | 	mSampleRate = WAVE.nSamplesPerSec;
107 | 
108 | 	mSamples = new int[mLength];
109 | 
110 | 	const int bufferSize = 65536;
111 | 
112 | 	short *buffer = new short[bufferSize * nChannels];
113 | 	int totalRead = 0;
114 | 
115 | 	while (totalRead < mLength)
116 | 	{
117 | 		int readCount = fread(buffer, (bitsPerSample / 8 * nChannels), bufferSize, f);
118 | 
119 | 		for (int i = 0 ; i < readCount ; ++i)
120 | 		{
121 | 			if (nChannels == 1)
122 | 			{
123 | 				mSamples[totalRead + i] = buffer[i * nChannels];
124 | 			}
125 | 			if (channel >= 0 && channel < nChannels)
126 | 			{
127 | 				mSamples[totalRead + i] = buffer[i * nChannels + channel];
128 | 			}
129 | 			else
130 | 			{
131 | 				// Mixdown
132 | 				int total = 0;
133 | 				for (int c = 0 ; c < nChannels ; ++c)
134 | 					total += buffer[i * nChannels + c];
135 | 				mSamples[totalRead + i] = total;
136 | 			}
137 | 		}
138 | 
139 | 		totalRead += readCount;
140 | 	}
141 | 
142 | 	delete [] buffer;
143 | 
144 | 	fclose(f);
145 | 
146 | 	return true;
147 | }
148 | 
149 | 
150 | int Wave::getLength() const
151 | {
152 | 	return mLength;
153 | }
154 | 
155 | 
156 | int Wave::getSampleRate() const
157 | {
158 | 	return mSampleRate;
159 | }
160 | 
161 | 
162 | 
163 | int Wave::get(int samplePosition) const
164 | {
165 | 	if (samplePosition >= mLength || samplePosition < 0)
166 | 		return 0;
167 | 
168 | 	return mSamples[samplePosition];
169 | }
170 | 


--------------------------------------------------------------------------------
/src/Wave.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class Wave
 4 | {
 5 | 	struct Chunk
 6 | 	{
 7 | 		char ckID[4];
 8 | 		long cksize;
 9 | 	};
10 | 
11 | 	int *mSamples;
12 | 	int mLength, mSampleRate;
13 | public:
14 | 	Wave();
15 | 	~Wave();
16 | 	bool load(const char *filename, int channel = -1);
17 | 
18 | 	int getLength() const;
19 | 	int getSampleRate() const;
20 | 	int get(int samplePosition) const;
21 | };
22 | 


--------------------------------------------------------------------------------