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

//=============================================================================
//                      A simple sine wave synthesizer
//=============================================================================

#ifndef SYNTHESIZER_H
#define SYNTHESIZER_H

#include "audioplayeradapter.h"
#include "waveformgenerator.h"
#include "pcmwriterinterface.h"
#include "../../system/simplethreadhandler.h"


//=============================================================================
//                  Structure describing an envelope
//=============================================================================


struct Envelope
{
    double attack;      
    double decay;       
    double sustain;     
    double release;     
    double hammer;      

    Envelope(double attack=0, double decay=0,
             double sustain=0, double release=0,
             double hammer=0);
};

//=============================================================================
//                          Structure of a tone
//=============================================================================


struct Tone
{
    int keynumber;                      
    double frequency;                   
    double leftamplitude;               
    double rightamplitude;              
    double phaseshift;                  
    Envelope envelope;                  

    int_fast64_t clock;                 
    int stage;                          
    double amplitude;                   

    WaveformGenerator::Waveform waveform; 
};


//=============================================================================
//                          Synthesizer class
//=============================================================================


class Synthesizer : public PCMWriterInterface
{
public:

    using Spectrum = std::map<double,double>;   // type of spectrum

    Synthesizer ();

    virtual void init (int sampleRate, int channels) override final;
    virtual void exit () override final { mWaveformGenerator.exit();}

    void setNumberOfKeys (int numberOfKeys);

    void preCalculateWaveform   (const int id, const Spectrum &spectrum);

    void playSound              (const int id,
                                 const double frequency,
                                 const double volume,
                                 const Envelope &env,
                                 const bool waitforcomputation = false,
                                 const bool stereo = true);

    void ModifySustainLevel     (const int id, const double level);

    void releaseSound           (const int id);

    bool isPlaying              (const int id) const;

    virtual bool generateAudioSignal(AudioBase::PacketType &outputPacket) override final;

private:

    using Waveform = WaveformGenerator::Waveform;

    WaveformGenerator mWaveformGenerator;

    int mNumberOfKeys;                      

    std::vector<Tone> mPlayingTones;        
    mutable std::mutex mPlayingMutex;       

    const int_fast64_t  SineLength = 16384; 
    const double CutoffVolume = 0.00001;    

    Waveform mSineWave;                     

    static const std::vector< std::vector<int> > mHammerKnockFFT;
    FFTRealVector mHammerWaveLeft;          
    FFTRealVector mHammerWaveRight;

    int mReverbSize,mReverbCounter;
    int mDelay1,mDelay2,mDelay3;
    std::vector<double> mReverbL,mReverbR;    
    double mIntensity;

    const Tone* getSoundPointer (const int id) const;
    Tone* getSoundPointer (const int id);
    void updateIntensity();
};

#endif // SYNTHESIZER_H