keyrecognizer.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/.
 *****************************************************************************/

//=============================================================================
//                              Key recognizer
//=============================================================================

#ifndef KEYRECOGNIZER_H
#define KEYRECOGNIZER_H

#include "../system/simplethreadhandler.h"
#include "../messages/messagelistener.h"
#include "../piano/piano.h"
#include "../math/fftimplementation.h"



class KeyRecognizerCallback
{
public:
    virtual void keyRecognized(int keyIndex, double frequency) = 0;
};




class KeyRecognizer : public SimpleThreadHandler
{
private:
    static const int    M;                              
    static const double fmin;                           
    static const double fmax;                           

public:
    KeyRecognizer (KeyRecognizerCallback *callback);    // Constructor
    ~KeyRecognizer(){}                                  // Empty destructor

    void init(bool optimize);                           // Initialize (optimize FFT)
    void recognizeKey(bool forceRestart,                // Recognize a key:
                      const Piano *piano,               // This function is called by
                      FFTDataPointer fftPointer,        // the SignalAnalyzer
                      int selectedKey, bool keyForced);

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

    double detectForcedFrequency();                     // Handle forced keys
    double detectFrequencyInTreble();                   // Handle keys in the treble
    void constructLogSpec();                            // Construct logarithmic spectrum
    void signalPreprocessing();                         // Preprocessing of the signal
    void defineKernel();                                // Define convolution kernel
    double estimateFrequency();                         // Frequency recognition
    int findNearestKey (double f);                      // Find nearest key, 0 if none

private:
    KeyRecognizerCallback *mCallback;                   
    FFTDataPointer mFFTPtr;                             
    double mConcertPitch;                               
    const Piano *mPiano;                                
    int mNumberOfKeys;                                  
    int mKeyNumberOfA;                                  
    FFT_Implementation mFFT;                            
    std::vector<double> mLogSpec;                       
    std::vector<double> mFlatSpectrum;                    
    FFTComplexVector mKernelFFT;                        
    FFTComplexVector mFlatFFT;                    
    FFTRealVector mConvolution;                         
    int mSelectedKey;                                   
    bool mKeyForced;                                    

private:
    static const double logfmin;                        
    static const double logfmax;                        
    double mtof (int m);                                
    int ftom (double f);                                

    void Write(std::string filename, std::vector<double> &v, bool log=true); // only for development
};

#endif // KEYRECOGNIZER_H