wave.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright 2016-2017 Karolin Stange, Christoph Wick, and Haye Hinrichsen
 *
 * This file is part of JustIntonation.
 *
 * JustIntonation 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.
 *
 * JustIntonation 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 JustIntonation. If not, see http://www.gnu.org/licenses/.
 *****************************************************************************/

//=============================================================================
//            Wave: Class holding the sampled sound for one key
//=============================================================================

#ifndef WAVE_H
#define WAVE_H

#include <QVector>
#include <QIODevice>
#include <complex>


class Wave
{
public:
    Wave();

    //friend class Sampler;

    bool read (QIODevice &iodevice);
    bool write (QIODevice &iodevice);

    bool insert (const QVector<qint32> &L, const QVector<qint32> &R,
                 const bool release, const double amplitude);

    void printInfo (int keynumber=0);

    quint32 getRepetitionIndex()                { return mRepetitionIndex; }
    double getRepetitionFactor()                { return mRepetitionFactor; }
    const QVector<qint16>* getSustainSample()   { return &mSustainSample; }
    const QVector<qint16>* getReleaseSample()   { return &mReleaseSample; }
    int getReleaseShift()                       { return mReleaseShift; }
    int getSustainShift()                       { return mSustainShift; }

    double getEnvelope (int index) { return mEnvelope[index/envelopeWidth]; }

    bool envelopeExists () { return mEnvelope.size() > 0; }
    bool waveFormExists () { return mSustainSample.size() > 0; }
    bool releaseExists ()  { return mReleaseSample.size() > 0; }

    void computeTriangularWave(double frequency, int samplerate, double stereo);
private:
    quint32 mRepetitionIndex;           
    double mRepetitionFactor;           
    QVector<qint16> mSustainSample;     
    QVector<qint16> mReleaseSample;     
    int mSustainShift;                  
    int mReleaseShift;                  
    QVector<double> mEnvelope;          

    void computeEnvelope(int samplerate);
    void automaticCyclicMorphing();     

private:
    const int maxNumberOfFrames = (1<<20)-2;    
    const int envelopeWidth = 0x1000;           
};

#endif // WAVE_H