engines/gig/Filter.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 Christian Schoenebeck                              *
 *   Copyright (C) 2006 Christian Schoenebeck and Andreas Persson          *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_GIG_FILTER_H__
#define __LS_GIG_FILTER_H__

#include "../../common/global.h"

#include <gig.h>

namespace LinuxSampler { namespace gig {

    class FilterBase {
    public:
        virtual float Apply(float x) = 0;
        virtual void SetParameters(float f1, float f2, float scale) = 0;
        virtual ~FilterBase() {}

        virtual void Reset() {
            y1 = y2 = y3 = x1 = x2 = x3 = 0;
        }

    private:
        float y1, y2, y3;

    protected:
        float a1, a2, a3, x1, x2, x3;

        void KillDenormal(float& f) {
            f += 1e-18f;
            f -= 1e-18f;
        }

        float ApplyA(float x) {
            float y = x - a1 * y1 - a2 * y2 - a3 * y3;
            KillDenormal(y);
            y3 = y2;
            y2 = y1;
            y1 = y;
            return y;
        }
    };

    class LowpassFilter : public FilterBase {
    protected:
        float b0;
    public:
        float Apply(float x) {
            return ApplyA(b0 * x);
        }

        void SetParameters(float f1, float f2, float scale) {
            float f1_2 = f1 * f1;
            b0 = f1_2 * scale;
            a1 = f2;
            a2 = f1_2 - 1;
            a3 = -f2;
        }
    };

    class BandpassFilter : public FilterBase {
        float b0, b2;
    public:
        float Apply(float x) {
            float y = ApplyA(b0 * x + b2 * x2);
            x2 = x1;
            x1 = x;
            return y;
        }

        void SetParameters(float f1, float f2, float scale) {
            b0 = f1 * scale;
            b2 = -b0;
            a1 = f2;
            a2 = f1 * f1 - 1;
            a3 = -f2;
        }
    };

    class HighpassFilter : public FilterBase {
        float scale;
    public:
        float Apply(float x) {
            float y = ApplyA(-x + x1 + x2 - x3);
            x3 = x2;
            x2 = x1;
            x1 = x;
            return y * scale;
        }

        void SetParameters(float f1, float f2, float scale) {
            a1 = f2;
            a2 = f1 * f1 - 1;
            a3 = -f2;
            this->scale = scale;
        }
    };

    class BandrejectFilter : public FilterBase {
        float scale, b2;
    public:
        float Apply(float x) {
            float y = ApplyA(x - x1 + b2 * x2 + x3);
            x3 = x2;
            x2 = x1;
            x1 = x;
            return y * scale;
        }

        void SetParameters(float f1, float f2, float scale) {
            b2 = f1 * f1 - 1;
            a1 = f2;
            a2 = b2;
            a3 = -f2;
            this->scale = scale;
        }
    };

    class LowpassTurboFilter : public LowpassFilter {
        float b20, y21, y22, y23;
    public:
        float Apply(float x) {
            float y = b20 * LowpassFilter::Apply(x)
                - a1 * y21 - a2 * y22 - a3 * y23;
            KillDenormal(y);
            y23 = y22;
            y22 = y21;
            y21 = y;

            return y;
        }

        void SetParameters(float f1, float f2, float scale) {
            LowpassFilter::SetParameters(f1, f2, scale);
            b20 = b0 * 0.5;
        }

        void Reset() {
            LowpassFilter::Reset();
            y21 = y22 = y23 = 0;
        }
    };

    /**
     * These are filters similar to the ones from Gigasampler.
     */
    class Filter {
        protected:
            HighpassFilter     HPFilter;
            BandpassFilter     BPFilter;
            LowpassFilter      LPFilter;
            BandrejectFilter   BRFilter;
            LowpassTurboFilter LPTFilter;
            FilterBase*        pFilter;

        public:
            Filter() {
                // set filter type to 'lowpass' by default
                pFilter = &LPFilter;
            }

            void SetType(::gig::vcf_type_t FilterType) {
                switch (FilterType) {
                    case ::gig::vcf_type_highpass:
                        pFilter = &HPFilter;
                        break;
                    case ::gig::vcf_type_bandreject:
                        pFilter = &BRFilter;
                        break;
                    case ::gig::vcf_type_bandpass:
                        pFilter = &BPFilter;
                        break;
                    case ::gig::vcf_type_lowpassturbo:
                        pFilter = &LPTFilter;
                        break;
                    default:
                        pFilter = &LPFilter;
                }
            }

            void SetParameters(float cutoff, float resonance, float fs) {
                float f1 = cutoff * 0.0075279;
                float f2 = f1 - 1 + resonance * cutoff * (-5.5389e-5 + 1.1982e-7 * cutoff);
                float scale = resonance < 51 ? 1.0f : 1.3762f - 0.0075073f * resonance;
                pFilter->SetParameters(f1, f2, scale);
            }

            void Reset() {
                HPFilter.Reset();
                BPFilter.Reset();
                LPFilter.Reset();
                BRFilter.Reset();
                LPTFilter.Reset();
            }

            float Apply(float in) {
                return pFilter->Apply(in);
            }
    };

}} //namespace LinuxSampler::gig

#endif // __LS_GIG_FILTER_H__
1	schoenebeck	53	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5	schoenebeck	56	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	505	* Copyright (C) 2005 Christian Schoenebeck *
7	persson	877	* Copyright (C) 2006 Christian Schoenebeck and Andreas Persson *
8	schoenebeck	53	* *
9			* This program is free software; you can redistribute it and/or modify *
10			* it under the terms of the GNU General Public License as published by *
11			* the Free Software Foundation; either version 2 of the License, or *
12			* (at your option) any later version. *
13			* *
14			* This program is distributed in the hope that it will be useful, *
15			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
16			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17			* GNU General Public License for more details. *
18			* *
19			* You should have received a copy of the GNU General Public License *
20			* along with this program; if not, write to the Free Software *
21			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
22			* MA 02111-1307 USA *
23			***************************************************************************/
24
25			#ifndef __LS_GIG_FILTER_H__
26			#define __LS_GIG_FILTER_H__
27
28			#include "../../common/global.h"
29
30	schoenebeck	505	#include <gig.h>
31
32	persson	877	namespace LinuxSampler { namespace gig {
33	schoenebeck	53
34	persson	877	class FilterBase {
35			public:
36			virtual float Apply(float x) = 0;
37			virtual void SetParameters(float f1, float f2, float scale) = 0;
38			virtual ~FilterBase() {}
39	schoenebeck	53
40	persson	877	virtual void Reset() {
41			y1 = y2 = y3 = x1 = x2 = x3 = 0;
42			}
43	schoenebeck	53
44	persson	877	private:
45			float y1, y2, y3;
46	schoenebeck	53
47	persson	877	protected:
48			float a1, a2, a3, x1, x2, x3;
49
50			void KillDenormal(float& f) {
51			f += 1e-18f;
52			f -= 1e-18f;
53			}
54
55			float ApplyA(float x) {
56			float y = x - a1 * y1 - a2 * y2 - a3 * y3;
57			KillDenormal(y);
58			y3 = y2;
59			y2 = y1;
60			y1 = y;
61			return y;
62			}
63			};
64
65			class LowpassFilter : public FilterBase {
66			protected:
67			float b0;
68			public:
69			float Apply(float x) {
70			return ApplyA(b0 * x);
71			}
72
73			void SetParameters(float f1, float f2, float scale) {
74			float f1_2 = f1 * f1;
75			b0 = f1_2 * scale;
76			a1 = f2;
77			a2 = f1_2 - 1;
78			a3 = -f2;
79			}
80			};
81
82			class BandpassFilter : public FilterBase {
83			float b0, b2;
84			public:
85			float Apply(float x) {
86			float y = ApplyA(b0 * x + b2 * x2);
87			x2 = x1;
88			x1 = x;
89			return y;
90			}
91
92			void SetParameters(float f1, float f2, float scale) {
93			b0 = f1 * scale;
94			b2 = -b0;
95			a1 = f2;
96			a2 = f1 * f1 - 1;
97			a3 = -f2;
98			}
99			};
100
101			class HighpassFilter : public FilterBase {
102			float scale;
103			public:
104			float Apply(float x) {
105			float y = ApplyA(-x + x1 + x2 - x3);
106			x3 = x2;
107			x2 = x1;
108			x1 = x;
109			return y * scale;
110			}
111
112			void SetParameters(float f1, float f2, float scale) {
113			a1 = f2;
114			a2 = f1 * f1 - 1;
115			a3 = -f2;
116			this->scale = scale;
117			}
118			};
119
120			class BandrejectFilter : public FilterBase {
121			float scale, b2;
122			public:
123			float Apply(float x) {
124			float y = ApplyA(x - x1 + b2 * x2 + x3);
125			x3 = x2;
126			x2 = x1;
127			x1 = x;
128			return y * scale;
129			}
130
131			void SetParameters(float f1, float f2, float scale) {
132			b2 = f1 * f1 - 1;
133			a1 = f2;
134			a2 = b2;
135			a3 = -f2;
136			this->scale = scale;
137			}
138			};
139
140			class LowpassTurboFilter : public LowpassFilter {
141			float b20, y21, y22, y23;
142			public:
143			float Apply(float x) {
144			float y = b20 * LowpassFilter::Apply(x)
145			- a1 * y21 - a2 * y22 - a3 * y23;
146			KillDenormal(y);
147			y23 = y22;
148			y22 = y21;
149			y21 = y;
150
151			return y;
152			}
153
154			void SetParameters(float f1, float f2, float scale) {
155			LowpassFilter::SetParameters(f1, f2, scale);
156			b20 = b0 * 0.5;
157			}
158
159			void Reset() {
160			LowpassFilter::Reset();
161			y21 = y22 = y23 = 0;
162			}
163			};
164
165	schoenebeck	53	/**
166	schoenebeck	80	* These are filters similar to the ones from Gigasampler.
167	schoenebeck	53	*/
168			class Filter {
169			protected:
170	persson	877	HighpassFilter HPFilter;
171			BandpassFilter BPFilter;
172			LowpassFilter LPFilter;
173			BandrejectFilter BRFilter;
174			LowpassTurboFilter LPTFilter;
175			FilterBase* pFilter;
176	persson	685
177	schoenebeck	53	public:
178	schoenebeck	319	Filter() {
179	schoenebeck	53	// set filter type to 'lowpass' by default
180			pFilter = &LPFilter;
181			}
182
183	persson	877	void SetType(::gig::vcf_type_t FilterType) {
184	schoenebeck	53	switch (FilterType) {
185			case ::gig::vcf_type_highpass:
186			pFilter = &HPFilter;
187			break;
188	persson	877	case ::gig::vcf_type_bandreject:
189			pFilter = &BRFilter;
190			break;
191	schoenebeck	53	case ::gig::vcf_type_bandpass:
192			pFilter = &BPFilter;
193			break;
194	persson	877	case ::gig::vcf_type_lowpassturbo:
195			pFilter = &LPTFilter;
196			break;
197	schoenebeck	53	default:
198			pFilter = &LPFilter;
199			}
200			}
201
202	persson	877	void SetParameters(float cutoff, float resonance, float fs) {
203			float f1 = cutoff * 0.0075279;
204			float f2 = f1 - 1 + resonance * cutoff * (-5.5389e-5 + 1.1982e-7 * cutoff);
205			float scale = resonance < 51 ? 1.0f : 1.3762f - 0.0075073f * resonance;
206			pFilter->SetParameters(f1, f2, scale);
207	schoenebeck	53	}
208
209	schoenebeck	319	void Reset() {
210			HPFilter.Reset();
211			BPFilter.Reset();
212			LPFilter.Reset();
213	persson	877	BRFilter.Reset();
214			LPTFilter.Reset();
215	schoenebeck	319	}
216
217	persson	877	float Apply(float in) {
218			return pFilter->Apply(in);
219	schoenebeck	53	}
220			};
221
222			}} //namespace LinuxSampler::gig
223
224			#endif // __LS_GIG_FILTER_H__