Work updates - add synths and improve

include/SineSynth.h

@@ -1,12 +1,13 @@
 #pragma once
 
 #include <algorithm>
-#include <cmath>
 #include <cstdint>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <vector>
+#include <random>
+#include <mpfr.h>
 
 using std::shared_ptr;
 using std::vector;
@@ -15,13 +16,18 @@ using std::cos;
 using std::for_each;
 using std::sin;
 
-class Generator {
+template <typename dataType>
+class Generator
+{
 public:
-    virtual float getSample() = 0;
-    virtual void getSamples(size_t nSamples, float* buf);
+    virtual dataType getSample() = 0;
+    virtual void getSamples(size_t nSamples, dataType *buf);
 
     virtual float getFrequency() const;
-    virtual void setFrequency(float _frequency);
+    virtual void setFrequency(float frequency);
+
+    virtual float getAmplitude() const;
+    virtual void setAmplitude(float amplitude);
 
     virtual bool isEnabled() const;
     virtual void enable();
@@ -30,11 +36,11 @@ public:
     virtual ~Generator();
 
     // disallow copy of virtual interface
-    Generator(Generator const&) = delete;
-    Generator& operator=(Generator const&) = delete;
+    Generator(Generator const &) = delete;
+    Generator &operator=(Generator const &) = delete;
 
 protected:
-    Generator(uint32_t _sampleRate, float _frequency, float _amplitude);
+    Generator(uint32_t _sampleRate, float _frequency, float _amplitude = 1);
     uint32_t sampleRate;
     float frequency;
     float amplitude;
@@ -43,64 +49,94 @@ protected:
 private:
 };
 
-class SineGenerator : public Generator {
+template <typename dataType>
+class SineGenerator : public Generator<dataType>
+{
 public:
-    SineGenerator(uint32_t _sampleRate, float _frequency, float _amplitude);
+    SineGenerator(uint32_t _sampleRate, float _frequency, float _amplitude = 1);
 
-    float getSample() final;
+    dataType getSample() final;
 
     void setFrequency(float _frequency) final;
+    void setFrequency(mpfr_t frequency);
 
     virtual ~SineGenerator();
 
 private:
-    float instPhase;
-    float phaseIncr;
+    mpfr_t instPhase;
+    mpfr_t phaseIncr;
+
+    // Constant 2*pi
+    mpfr_t PI_2;
+
+    mpfr_t tmpA;
 };
 
-class NoiseGenerator : public Generator {
+template <typename dataType>
+class NoiseGenerator : public Generator<dataType>
+{
 public:
-    NoiseGenerator(uint32_t _sampleRate, uint8_t rate, float _amplitude);
+    enum NOISE_TYPE
+    {
+        WHITE,
+    };
 
-    float getSample() final;
+    NoiseGenerator(uint32_t _sampleRate, NOISE_TYPE type, float _amplitude = 1);
+
+    dataType getSample() final;
     virtual ~NoiseGenerator();
 
-    uint8_t rate;
-    static const uint16_t rateTable[];
-
 private:
-    int16_t level;
-    uint16_t sampleCount;
+    std::mt19937_64 rand_gen;
 };
 
-class SampleGenerator : public Generator {
+template <typename dataType>
+class JTestGenerator : public Generator<dataType>
+{
 public:
-    SampleGenerator(uint32_t _sampleRate, uint16_t _playbackRate, float _amplitude, size_t nSamples, const float* samples);
-    SampleGenerator(uint32_t _sampleRate, uint16_t _playbackRate, float _amplitude, size_t nSamples, const int16_t* samples);
+    JTestGenerator(uint32_t sampleRate, uint8_t nbits);
 
-    float getSample() final;
-    virtual ~SampleGenerator();
-
-    uint16_t playbackRate;
+    dataType getSample() final;
+    virtual ~JTestGenerator();
 
 private:
-    vector<float> sample;
-    float oldest, older, old;
-    uint32_t counter;
-    static const uint16_t gaussTable[];
+    std::vector<dataType> loop;
+    typename std::vector<dataType>::const_iterator pos;
 };
 
-class SineSynth {
+template <typename dataType>
+class SweepGenerator : public Generator<dataType>
+{
+public:
+    SweepGenerator(uint32_t sampleRate, float startFreq, float endFreq, float length, float amplitude = 1);
+    virtual ~SweepGenerator();
+
+    dataType getSample() final;
+    float getFrequency() const;
+
+    void setAmplitude(float amplitude);
+
+private:
+    SineGenerator<dataType> sg;
+    mpfr_t startFreq;
+    mpfr_t curFreq;
+    mpfr_t freqStep;
+    mpfr_t endFreq;
+};
+
+template <typename dataType>
+class SineSynth
+{
 public:
     SineSynth(uint32_t _sampleRate);
 
-    void addSynth(shared_ptr<Generator>);
-    vector<shared_ptr<Generator>> getSynths() const;
+    void addSynth(shared_ptr<Generator<dataType>>);
+    vector<shared_ptr<Generator<dataType>>> getSynths() const;
     void clearSynths();
 
-    void getSamples(size_t nSamples, float* buf);
+    void getSamples(size_t nSamples, dataType *buf);
 
 private:
     uint32_t sampleRate;
-    vector<shared_ptr<Generator>> generators;
+    vector<shared_ptr<Generator<dataType>>> generators;
 };