Updates

include/SineSynth.h

@@ -1,49 +1,106 @@
 #pragma once
 
-#include <cstdint>
-#include <vector>
-#include <iterator>
+#include <algorithm>
 #include <cmath>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <vector>
 
+using std::shared_ptr;
 using std::vector;
-using std::iterator_traits;
 
-using std::sin;
 using std::cos;
+using std::for_each;
+using std::sin;
 
-class Generator
-{
+class Generator {
 public:
-    virtual void getSamples(const uint16_t nSamples, float *buf) = 0;
+    virtual float getSample() = 0;
+    virtual void getSamples(size_t nSamples, float* buf);
+
+    virtual float getFrequency() const;
+    virtual void setFrequency(float _frequency);
+
+    virtual bool isEnabled() const;
+    virtual void enable();
+    virtual void disable();
+
     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);
     uint32_t sampleRate;
     float frequency;
     float amplitude;
+    bool enabled;
 
 private:
 };
 
-class SineGenerator : public Generator
-{
+class SineGenerator : public Generator {
 public:
     SineGenerator(uint32_t _sampleRate, float _frequency, float _amplitude);
-    void getSamples(uint16_t nSamples, float *buf) final;
+
+    float getSample() final;
+
+    void setFrequency(float _frequency) final;
+
     virtual ~SineGenerator();
 
 private:
-    uint32_t tick;
+    float instPhase;
     float phaseIncr;
 };
 
-class SineSynth
-{
+class NoiseGenerator : public Generator {
+public:
+    NoiseGenerator(uint32_t _sampleRate, uint8_t rate, float _amplitude);
+
+    float getSample() final;
+    virtual ~NoiseGenerator();
+
+    uint8_t rate;
+    static const uint16_t rateTable[];
+
 private:
-    vector<SineGenerator> generators;
+    int16_t level;
+    uint16_t sampleCount;
+};
+
+class SampleGenerator : public Generator {
+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);
+
+    float getSample() final;
+    virtual ~SampleGenerator();
+
+    uint16_t playbackRate;
+
+private:
+    vector<float> sample;
+    float oldest, older, old;
+    uint32_t counter;
+    static const uint16_t gaussTable[];
+};
+
+class SineSynth {
+public:
+    SineSynth(uint32_t _sampleRate);
+
+    void addSynth(shared_ptr<Generator>);
+    vector<shared_ptr<Generator>> getSynths() const;
+    void clearSynths();
+
+    void getSamples(size_t nSamples, float* buf);
+
+private:
+    uint32_t sampleRate;
+    vector<shared_ptr<Generator>> generators;
 };