signalanalyzer.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright 2015 Haye Hinrichsen, Christoph Wick
 *
 * This file is part of Entropy Piano Tuner.
 *
 * Entropy Piano Tuner 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 3 of the License, or (at your
 * option) any later version.
 *
 * Entropy Piano Tuner 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
 * Entropy Piano Tuner. If not, see http://www.gnu.org/licenses/.
 *****************************************************************************/

//=============================================================================
//                               Signal analyzer
//=============================================================================

#ifndef SIGNALANALYZER_H
#define SIGNALANALYZER_H

#include <fftw3.h>
#include <atomic>
#include <map>

#include "../system/simplethreadhandler.h"
#include "../messages/messagelistener.h"
#include "../audio/circularbuffer.h"
#include "../math/fftimplementation.h"
#include "fftanalyzer.h"
#include "keyrecognizer.h"
#include "overpull.h"

class AudioRecorderAdapter;


class SignalAnalyzer :
        public SimpleThreadHandler,
        public MessageListener,
        private KeyRecognizerCallback
{
public:
    static const int AUDIO_BUFFER_SIZE_IN_SECONDS = 60;             
    static const int MINIMAL_FFT_INTERVAL_IN_MILLISECONDS = 150;    

private:

    enum AnalyzerRole
    {
        ROLE_IDLE,                  
        ROLE_RECORD_KEYSTROKE,      
        ROLE_ROLLING_FFT,           
    };

public:
    SignalAnalyzer(AudioRecorderAdapter *recorder);
    ~SignalAnalyzer() {}

    void init();
    void exit() {}

    virtual void stop() override;

private:
    void handleMessage (MessagePtr m) override final;               // Message receiver

    void changeRole(AnalyzerRole role);
    void updateDataBufferSize();

    void workerFunction() override final;                           // Thread execution function

    void recordSignal();
    void analyzeSignal();
    void recordPostprocessing();                                    // processing after recording finished
    void updateOverpull();

    double signalPreprocessing(FFTWVector &signal);                 // Preprocessing of incoming signal
    void signalProcessing(FFTWVector &signal, int samplingrate);    // processing of the current data
    bool detectClipping(FFTWVector signal);                         // Clipping detector, not yet implemented
    void PerformFFT (FFTWVector &signal, FFTWVector &powerspec);    // Perform fast Fourier transformation
    void createPolygon (const FFTWVector &powerspec, FFTPolygon &poly) const;   // Create polygon for drawing

    int identifySelectedKey();              

    // callbacks
    virtual void keyRecognized(int keyIndex, double frequency) override final;


    void WriteSignal (std::string filename, const FFTWVector &signal);    // Development, will be removed
    void WriteFFT (std::string filename, const FFTWVector &fft);          // Development, will be removed

private:
    const Piano *mPiano;                    
    CircularBuffer<FFTWType> mDataBuffer;   
    std::mutex mDataBufferMutex;            
    AudioRecorderAdapter *mAudioRecorder;   
    std::atomic<bool> mRecording;           
    FFTWVector mProprocessedSignal;         
    FFTDataPointer mPowerspectrum;          

    FFT_Implementation mFFT;                

    FFTAnalyzer mFFTAnalyser;               
    KeyRecognizer mKeyRecognizer;           
    OverpullEstimator mOverpull;            
    std::map<int,int> mKeyCountStatistics;  
    std::mutex mKeyCountStatisticsMutex;    
    int mSelectedKey;                       
    bool mKeyForced;                        

    std::atomic<AnalyzerRole> mAnalyzerRole;
};

#endif // SIGNALANALYZER_H