dsp_filter.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016-2017 Robin Gareus <robin@gareus.org>
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#ifndef _dsp_filter_h_
#define _dsp_filter_h_
 
#include <atomic>
#include <cstdint>
#include <cstring>
#include <assert.h>
#include <glib.h>
#include <glibmm.h>
#include <fftw3.h>
 
#include "pbd/malign.h"
 
#include "ardour/buffer_set.h"
#include "ardour/chan_mapping.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
 
namespace ARDOUR { namespace DSP {
 
        class DspShm {
                public:
                        DspShm (size_t s = 0)
                                : _data (0)
                                , _size (0)
                        {
                                assert (sizeof(float) == sizeof (int32_t));
                                assert (sizeof(float) == sizeof (int));
                                allocate (s);
                        }
 
                        ~DspShm () {
                                cache_aligned_free (_data);
                        }
 
                        void allocate (size_t s) {
                                if (s == _size) { return; }
                                cache_aligned_free (_data);
                                cache_aligned_malloc ((void**) &_data, sizeof (float) * s);
                                if (_data) { _size = s; }
                        }
 
                        void clear () {
                                memset (_data, 0, sizeof(float) * _size);
                        }
 
                        float* to_float (size_t off) {
                                if (off >= _size) { return 0; }
                                return &(((float*)_data)[off]);
                        }
 
                        int32_t* to_int (size_t off) {
                                if (off >= _size) { return 0; }
                                return &(((int32_t*)_data)[off]);
                        }
 
                        void atomic_set_int (size_t off, int32_t val) {
                                /* no read or write that precedes the write we are
                                   about to do can be reordered past this fence.
                                */
                                std::atomic_thread_fence (std::memory_order_release);
                                ((int32_t*)_data)[off] = val;
                        }
 
                        int32_t atomic_get_int (size_t off) {
                                /* no read that precedes the read we are
                                   about to do can be reordered past this fence.
                                */
                                std::atomic_thread_fence (std::memory_order_acquire);
                                return (((int32_t*)_data)[off]);
                        }
 
                private:
                        void* _data;
                        size_t _size;
        };
 
        void memset (float *data, const float val, const uint32_t n_samples);
        void mmult (float *data, float *mult, const uint32_t n_samples);
        void peaks (const float *data, float &min, float &max, uint32_t n_samples);
 
        float log_meter (float power);
        float log_meter_coeff (float coeff);
 
        void process_map (BufferSet* bufs,
                          const ChanCount&   n_out,
                          const ChanMapping& in_map,
                          const ChanMapping& out_map,
                          pframes_t nframes, samplecnt_t offset);
 
        class LIBARDOUR_API LowPass {
                public:
                        LowPass (double samplerate, float freq);
                        void proc (float *data, const uint32_t n_samples);
                        void ctrl (float *data, const float val, const uint32_t n_samples);
                        void set_cutoff (float freq);
                        void reset () { _z =  0.f; }
                private:
                        float _rate;
                        float _z;
                        float _a;
        };
 
        class LIBARDOUR_API Biquad {
                public:
                        enum Type {
                                LowPass,
                                HighPass,
                                BandPassSkirt,
                                BandPass0dB,
                                Notch,
                                AllPass,
                                Peaking,
                                LowShelf,
                                HighShelf,
                                MatchedLowPass,
                                MatchedHighPass,
                                MatchedBandPass0dB,
                                MatchedPeaking
                        };
 
                        Biquad (double samplerate);
                        Biquad (const Biquad &other);
 
                        void run (float *data, const uint32_t n_samples);
                        void compute (Type t, double freq, double Q, double gain);
 
                        void configure (double a1, double a2, double b0, double b1, double b2);
 
                        /* copy coefficients from other instance, retain state */
                        void configure (Biquad const&);
 
                        float dB_at_freq (float freq) const;
 
                        void reset () { _z1 = _z2 = 0.0; }
 
                        void coefficients (double& a1, double& a2, double& b0, double& b1, double& b2) const;
                private:
                        void set_vicanek_poles (const double W0, const double Q, const double A = 1.0);
                        void calc_vicanek (const double W0, double& A0, double& A1, double& A2, double& phi0, double& phi1, double& phi2);
 
                        double _rate;
                        float  _z1, _z2;
                        double _a1, _a2;
                        double _b0, _b1, _b2;
        };
 
        class LIBARDOUR_API FFTSpectrum {
                public:
                        FFTSpectrum (uint32_t window_size, double rate);
                        ~FFTSpectrum ();
 
                        void set_data_hann (float const * const data, const uint32_t n_samples, const uint32_t offset = 0);
 
                        void execute ();
 
                        float power_at_bin (const uint32_t bin, const float norm = 1.f) const;
 
                        float freq_at_bin (const uint32_t bin) const {
                                return bin * _fft_freq_per_bin;
                        }
 
                private:
                        static Glib::Threads::Mutex fft_planner_lock;
                        float* hann_window;
 
                        void init (uint32_t window_size, double rate);
                        void reset ();
 
                        uint32_t _fft_window_size;
                        uint32_t _fft_data_size;
                        double   _fft_freq_per_bin;
 
                        float* _fft_data_in;
                        float* _fft_data_out;
                        float* _fft_power;
 
                        fftwf_plan _fftplan;
        };
 
        class LIBARDOUR_API Generator {
                public:
                        Generator ();
 
                        enum Type {
                                UniformWhiteNoise,
                                GaussianWhiteNoise,
                                PinkNoise,
                        };
 
                        void run (float *data, const uint32_t n_samples);
                        void set_type (Type t);
 
                private:
                        uint32_t randi ();
                        float    randf () { return (randi () / 1073741824.f) - 1.f; }
                        float    grandf ();
 
                        Type     _type;
                        uint32_t _rseed;
                        /* pink-noise */
                        float _b0, _b1, _b2, _b3, _b4, _b5, _b6;
                        /* gaussian white */
                        bool _pass;
                        float _rn;
 
        };
 
} } /* namespace */
#endif