SaProcessor.h

Go to the documentation of this file.

/* SaProcessor.h - declaration of SaProcessor class.
 *
 * Copyright (c) 2019 Martin Pavelek <he29/dot/HS/at/gmail/dot/com>
 *
 * Based partially on Eq plugin code,
 * Copyright (c) 2014 David French <dave/dot/french3/at/googlemail/dot/com>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * 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 (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef SAPROCESSOR_H
#define SAPROCESSOR_H
 
#include <atomic>
#include <fftw3.h>
#include <QMutex>
#include <QRgb>
#include <vector>
 
 
 
namespace lmms
{
 
template<class T>
class LocklessRingBuffer;
 
class SaControls;
class SampleFrame;
 

class SaProcessor
{
public:
        explicit SaProcessor(const SaControls *controls);
        virtual ~SaProcessor();
 
        // analysis thread and a method to terminate it
        void analyze(LocklessRingBuffer<SampleFrame> &ring_buffer);
        void terminate() {m_terminate = true;}
 
        // inform processor if any processing is actually required
        void setSpectrumActive(bool active);
        void setWaterfallActive(bool active);
        void flipRequest() {m_flipRequest = true;}      // request refresh of history buffer
 
        // configuration is taken from models in SaControls; some changes require
        // an exlicit update request (reallocation and window rebuild)
        void reallocateBuffers();
        void rebuildWindow();
        void clear();
        void clearHistory();
 
        const float *getSpectrumL() const {return m_normSpectrumL.data();}
        const float *getSpectrumR() const {return m_normSpectrumR.data();}
        const uchar *getHistory() const {return m_history.data();}
 
        // information about results and unit conversion helpers
        unsigned int inBlockSize() const {return m_inBlockSize;}
        unsigned int binCount() const;                  
        bool spectrumNotEmpty();                                
 
        unsigned int waterfallWidth() const;    
        unsigned int waterfallHeight() const {return m_waterfallHeight;}
        bool waterfallNotEmpty() const {return m_waterfallNotEmpty;}
 
        float binToFreq(unsigned int bin_index) const;
        float binBandwidth() const;
 
        float freqToXPixel(float frequency, unsigned int width) const;
        float xPixelToFreq(float x, unsigned int width) const;
 
        float ampToYPixel(float amplitude, unsigned int height) const;
        float yPixelToAmp(float y, unsigned int height) const;
 
        unsigned int getSampleRate() const;
        float getNyquistFreq() const;
 
        float getFreqRangeMin(bool linear = false) const;
        float getFreqRangeMax() const;
        float getAmpRangeMin(bool linear = false) const;
        float getAmpRangeMax() const;
 
        // Reallocation lock prevents the processor from changing size of its buffers.
        // It is used to keep consistent bin-to-frequency mapping while drawing the
        // spectrum and to make sure reading side does not find itself out of bounds.
        // The processor is meanwhile free to work on another block.
        QMutex m_reallocationAccess;
        // Data access lock prevents the processor from changing both size and content
        // of its buffers. It is used when writing to a result buffer, or when a friendly
        // class reads them and needs guaranteed data consistency.
        // It causes FFT analysis to be paused, so this lock should be used sparingly.
        // If using both locks at the same time, reallocation lock MUST be acquired first.
        QMutex m_dataAccess;
 
 
private:
        const SaControls *m_controls;
 
        // thread communication and control
        bool m_terminate;
 
        // currently valid configuration
        unsigned int m_zeroPadFactor = 2;               
        std::atomic<unsigned int> m_inBlockSize;
        unsigned int m_fftBlockSize;                    
        unsigned int m_sampleRate;
 
        // data buffers (roughly in the order of processing, from input to output)
        unsigned int m_framesFilledUp;
        std::vector<float> m_bufferL;                   
        std::vector<float> m_bufferR;                   
        std::vector<float> m_fftWindow;                 
        std::vector<float> m_filteredBufferL;   
        std::vector<float> m_filteredBufferR;   
        fftwf_plan m_fftPlanL;
        fftwf_plan m_fftPlanR;
        fftwf_complex *m_spectrumL;                             
        fftwf_complex *m_spectrumR;                             
        std::vector<float> m_absSpectrumL;              
        std::vector<float> m_absSpectrumR;              
        std::vector<float> m_normSpectrumL;             
        std::vector<float> m_normSpectrumR;     
 
        // spectrum history for waterfall: new normSpectrum lines are added on top
        std::vector<uchar> m_history_work;              
        std::vector<uchar> m_history;                   
        bool m_flipRequest;                                             
        std::atomic<unsigned int> m_waterfallHeight;    
                                                                                        // Note: high values may make it harder to see transients.
        const unsigned int m_waterfallMaxWidth = 3840;
 
        // book keeping
        bool m_spectrumActive;
        bool m_waterfallActive;
        std::atomic<unsigned int> m_waterfallNotEmpty;  
        bool m_reallocating;
 
        // merge L and R channels and apply gamma correction to make a spectrogram pixel
        QRgb makePixel(float left, float right) const;
 
        #ifdef SA_DEBUG
                unsigned int m_last_dump_time;
                unsigned int m_dump_count;
                float m_sum_execution;
                float m_max_execution;
        #endif
};
 
 
} // namespace lmms
 
#endif // SAPROCESSOR_H