WIP

Source/Veno/Audio/Synth/SynthInstance.cpp

@@ -0,0 +1,11 @@
+//
+// Created by versustune on 09.06.20.
+//
+
+#include "SynthInstance.h"
+
+#include <utility>
+
+SynthInstance::SynthInstance(std::string processId)
+        : m_processId(std::move(processId)) {
+}

Source/Veno/Audio/Synth/SynthInstance.h

@@ -0,0 +1,22 @@
+//
+// Created by versustune on 09.06.20.
+//
+
+#ifndef VENO_SYNTHINSTANCE_H
+#define VENO_SYNTHINSTANCE_H
+
+
+#include <string>
+
+// class that hold all voices, oscillators and other stuff :)
+class SynthInstance {
+private:
+    std::string m_processId;
+public:
+    explicit SynthInstance(std::string processId);
+    ~SynthInstance() = default;
+protected:
+};
+
+
+#endif //VENO_SYNTHINSTANCE_H

Source/Veno/Audio/VenoBuffer.cpp

@@ -0,0 +1,74 @@
+//
+// Created by versustune on 12.06.20.
+//
+
+#include <cmath>
+#include "VenoBuffer.h"
+
+VenoBuffer::VenoBuffer() {
+
+}
+
+VenoBuffer::~VenoBuffer() {
+    buffer.clear();
+    right.clear();
+    left.clear();
+}
+
+void VenoBuffer::reset(int size) {
+    if (size != buffer.size()) {
+        buffer.resize(size);
+        right.resize(size);
+        left.resize(size);
+    }
+    // reset to 0 dc :D
+    for (int i = 0; i < size; ++i) {
+        buffer[i] = 0;
+        left[i] = 0;
+        right[i] = 0;
+    }
+    leftPeak = 0;
+    rightPeak = 0;
+    monoPeak = 0;
+}
+
+void VenoBuffer::addMonoSample(float value, int index) {
+    buffer[index] = value;
+}
+
+void VenoBuffer::addLeftSample(float value, int index) {
+    left[index] = value;
+}
+
+void VenoBuffer::addRightSample(float value, int index) {
+    right[index] = value;
+}
+
+void VenoBuffer::calcPeak() {
+    for (int i = 0; i < buffer.size(); ++i) {
+        auto l = std::abs(left[i]);
+        auto r = std::abs(right[i]);
+        auto m = std::abs(buffer[i]);
+        if (m > monoPeak) {
+            monoPeak = m;
+        }
+        if (l > leftPeak) {
+            leftPeak = l;
+        }
+        if (r > rightPeak) {
+            rightPeak = r;
+        }
+    }
+}
+
+const std::vector<float> &VenoBuffer::getBuffer() const {
+    return buffer;
+}
+
+const std::vector<float> &VenoBuffer::getRight() const {
+    return right;
+}
+
+const std::vector<float> &VenoBuffer::getLeft() const {
+    return left;
+}

Source/Veno/Audio/VenoBuffer.h

@@ -0,0 +1,37 @@
+//
+// Created by versustune on 12.06.20.
+//
+
+#ifndef VENO_VENOBUFFER_H
+#define VENO_VENOBUFFER_H
+
+
+#include <vector>
+
+class VenoBuffer {
+private:
+    std::vector<float> buffer;
+    std::vector<float> right;
+    std::vector<float> left;
+public:
+    VenoBuffer();
+    ~VenoBuffer();
+    void reset(int size);
+    void addMonoSample(float value, int index);
+    void addLeftSample(float value, int index);
+    void addRightSample(float value, int index);
+
+    void calcPeak();
+    float leftPeak;
+    float rightPeak;
+    float monoPeak;
+
+    const std::vector<float> &getBuffer() const;
+
+    const std::vector<float> &getRight() const;
+
+    const std::vector<float> &getLeft() const;
+};
+
+
+#endif //VENO_VENOBUFFER_H

Source/Veno/Audio/WaveTable/SawWaves.cpp

@@ -0,0 +1,28 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#include "WaveTableGenerator.h"
+#include "../../Utils/Logger.h"
+#include "TableHelper.h"
+
+void generateSaw(WaveTableGroup *group) {
+    if (group == nullptr) {
+        return;
+    }
+    int tableLen = findTableLen();
+    int idx;
+    auto *freqWaveRe = new double[tableLen];
+    auto *freqWaveIm = new double[tableLen];
+
+    for (idx = 0; idx < tableLen; idx++) {
+        freqWaveIm[idx] = 0.0;
+    }
+    freqWaveRe[0] = freqWaveRe[tableLen >> 1] = 0.0;
+    for (idx = 1; idx < (tableLen >> 1); idx++) {
+        freqWaveRe[idx] = 1.0 / idx;                    // sawtooth spectrum
+        freqWaveRe[tableLen - idx] = -freqWaveRe[idx];  // mirror
+    }
+    fillTables(group, freqWaveRe, freqWaveIm, tableLen);
+    VeNo::Logger::infoDebugMessage("Generated clean Saw Wave");
+}

Source/Veno/Audio/WaveTable/SawWaves.h

@@ -0,0 +1,11 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#ifndef VENO_SAWWAVES_H
+#define VENO_SAWWAVES_H
+
+void generateSaw(WaveTableGroup *group);
+
+
+#endif //VENO_SAWWAVES_H

Source/Veno/Audio/WaveTable/SineWaves.cpp

@@ -0,0 +1,5 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#include "SineWaves.h"

Source/Veno/Audio/WaveTable/SineWaves.h

@@ -0,0 +1,14 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#ifndef VENO_SINEWAVES_H
+#define VENO_SINEWAVES_H
+
+
+class SineWaves {
+
+};
+
+
+#endif //VENO_SINEWAVES_H

Source/Veno/Audio/WaveTable/SquareWaves.cpp

@@ -0,0 +1,5 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#include "SquareWaves.h"

Source/Veno/Audio/WaveTable/SquareWaves.h

@@ -0,0 +1,14 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#ifndef VENO_SQUAREWAVES_H
+#define VENO_SQUAREWAVES_H
+
+
+class SquareWaves {
+
+};
+
+
+#endif //VENO_SQUAREWAVES_H

Source/Veno/Audio/WaveTable/TableHelper.cpp

@@ -0,0 +1,154 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#include "TableHelper.h"
+#include "../../Core/AudioConfig.h"
+#include "../../Utils.h"
+
+void fft(int N, double *ar, double *ai) {
+    int i, j, k, L;            /* indexes */
+    int M, TEMP, LE, LE1, ip;  /* M = log N */
+    int NV2, NM1;
+    double t;               /* temp */
+    double Ur, Ui, Wr, Wi, Tr, Ti;
+    double Ur_old;
+
+// if ((N > 1) && !(N & (N - 1)))   // make sure we have a power of 2
+
+    NV2 = N >> 1;
+    NM1 = N - 1;
+    TEMP = N; /* get M = log N */
+    M = 0;
+    while (TEMP >>= 1) ++M;
+
+/* shuffle */
+    j = 1;
+    for (i = 1; i <= NM1; i++) {
+        if (i < j) {             /* swap a[i] and a[j] */
+            t = ar[j - 1];
+            ar[j - 1] = ar[i - 1];
+            ar[i - 1] = t;
+            t = ai[j - 1];
+            ai[j - 1] = ai[i - 1];
+            ai[i - 1] = t;
+        }
+
+        k = NV2;             /* bit-reversed counter */
+        while (k < j) {
+            j -= k;
+            k /= 2;
+        }
+
+        j += k;
+    }
+
+    LE = 1.;
+    for (L = 1; L <= M; L++) {            // stage L
+        LE1 = LE;                         // (LE1 = LE/2)
+        LE *= 2;                          // (LE = 2^L)
+        Ur = 1.0;
+        Ui = 0.;
+        Wr = std::cos(M_PI / (float) LE1);
+        Wi = -std::sin(M_PI / (float) LE1); // Cooley, Lewis, and Welch have "+" here
+        for (j = 1; j <= LE1; j++) {
+            for (i = j; i <= N; i += LE) { // butterfly
+                ip = i + LE1;
+                Tr = ar[ip - 1] * Ur - ai[ip - 1] * Ui;
+                Ti = ar[ip - 1] * Ui + ai[ip - 1] * Ur;
+                ar[ip - 1] = ar[i - 1] - Tr;
+                ai[ip - 1] = ai[i - 1] - Ti;
+                ar[i - 1] = ar[i - 1] + Tr;
+                ai[i - 1] = ai[i - 1] + Ti;
+            }
+            Ur_old = Ur;
+            Ur = Ur_old * Wr - Ui * Wi;
+            Ui = Ur_old * Wi + Ui * Wr;
+        }
+    }
+}
+
+float makeWaveTable(WaveTableGroup *group, int len, double *ar, double *ai, double scale, double topFreq) {
+    fft(len, ar, ai);
+
+    if (scale == 0.0) {
+        // calc normal
+        double max = 0;
+        for (int idx = 0; idx < len; idx++) {
+            double temp = fabs(ai[idx]);
+            if (max < temp)
+                max = temp;
+        }
+        scale = 1.0 / max * .999;
+    }
+
+    // normalize
+    auto *wave = new float[len];
+    for (int idx = 0; idx < len; idx++)
+        wave[idx] = ai[idx] * scale;
+
+    if (group->m_numWaveTables < WaveTableGroup::numWaveTableSlots) {
+        auto table = group->m_WaveTables[group->m_numWaveTables] = new WaveTableObject();
+        float *waveTable = group->m_WaveTables[group->m_numWaveTables]->m_waveTable = new float[len + 1];
+        table->m_waveTableLen = len;
+        table->m_topFreq = topFreq;
+        ++group->m_numWaveTables;
+
+        // fill in wave
+        for (long idx = 0; idx < len; idx++)
+            waveTable[idx] = wave[idx];
+        waveTable[len] = waveTable[0];  // duplicate for interpolation wraparound
+
+        return 0;
+    } else {
+        scale = 0.0;
+    }
+    return (float) scale;
+}
+
+int fillTables(WaveTableGroup *group, double *freqWaveRe, double *freqWaveIm, int numSamples) {
+    int idx;
+
+    freqWaveRe[0] = freqWaveIm[0] = 0.0;
+    freqWaveRe[numSamples >> 1] = freqWaveIm[numSamples >> 1] = 0.0;
+
+    int maxHarmonic = numSamples >> 1;
+    const double minVal = 0.000001; // -120 dB
+    while ((fabs(freqWaveRe[maxHarmonic]) + fabs(freqWaveIm[maxHarmonic]) < minVal) && maxHarmonic) --maxHarmonic;
+
+    double topFreq = 2.0 / 3.0 / maxHarmonic;
+
+    double *ar = new double[numSamples];
+    double *ai = new double[numSamples];
+    double scale = 0.0;
+    int numTables = 0;
+    while (maxHarmonic) {
+        // fill the table in with the needed harmonics
+        for (idx = 0; idx < numSamples; idx++)
+            ar[idx] = ai[idx] = 0.0;
+        for (idx = 1; idx <= maxHarmonic; idx++) {
+            ar[idx] = freqWaveRe[idx];
+            ai[idx] = freqWaveIm[idx];
+            ar[numSamples - idx] = freqWaveRe[numSamples - idx];
+            ai[numSamples - idx] = freqWaveIm[numSamples - idx];
+        }
+
+        // make the wavetable
+        scale = makeWaveTable(group, numSamples, ar, ai, scale, topFreq);
+        numTables++;
+
+        // prepare for next table
+        topFreq *= 2;
+        maxHarmonic >>= 1;
+    }
+    return numTables;
+}
+
+float getNextRand() {
+    return std::rand() / double(RAND_MAX);
+}
+
+int findTableLen() {
+    int maxHarms = AudioConfig::getInstance()->getSampleRate() / (5.0 * 20) + 0.5;
+    return VeNo::Utils::nextPowerOfTwo(maxHarms) * 2;
+}

Source/Veno/Audio/WaveTable/TableHelper.h

@@ -0,0 +1,34 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#ifndef VENO_TABLEHELPER_H
+#define VENO_TABLEHELPER_H
+
+#include <cmath>
+#include <cstdlib>
+#include "WaveTableGenerator.h"
+
+#define M_PI        3.14159265358979323846
+#define DOUBLE_PI   6.283185307179586476925286766559
+
+/*
+ in-place complex fft
+ After Cooley, Lewis, and Welch; from Rabiner & Gold (1975)
+ program adapted from FORTRAN
+ by K. Steiglitz  (ken@princeton.edu)
+ Computer Science Dept.
+ Princeton University 08544
+*/
+void fft(int N, double *ar, double *ai);
+
+float makeWaveTable(WaveTableGroup *group, int len, double *ar, double *ai, double scale, double topFreq);
+
+// utils stuff
+int fillTables(WaveTableGroup *group, double *freqWaveRe, double *freqWaveIm, int numSamples);
+
+int findTableLen();
+
+float getNextRand();
+
+#endif //VENO_TABLEHELPER_H

Source/Veno/Audio/WaveTable/TriangleWaves.cpp

@@ -0,0 +1,5 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#include "TriangleWaves.h"

Source/Veno/Audio/WaveTable/TriangleWaves.h

@@ -0,0 +1,14 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#ifndef VENO_TRIANGLEWAVES_H
+#define VENO_TRIANGLEWAVES_H
+
+
+class TriangleWaves {
+
+};
+
+
+#endif //VENO_TRIANGLEWAVES_H

Source/Veno/Audio/WaveTable/VeNoXWaves.cpp

@@ -0,0 +1,5 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#include "VeNoXWaves.h"

Source/Veno/Audio/WaveTable/VeNoXWaves.h

@@ -0,0 +1,14 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#ifndef VENO_VENOXWAVES_H
+#define VENO_VENOXWAVES_H
+
+
+class VeNoXWaves {
+
+};
+
+
+#endif //VENO_VENOXWAVES_H

Source/Veno/Audio/WaveTable/WaveTableGenerator.cpp

@@ -0,0 +1,47 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#include "WaveTableGenerator.h"
+#include "../../Core/AudioConfig.h"
+#include "WavesInlcuder.h"
+
+void WaveTableGenerator::init() {
+    //if the sampleRate changed... the WaveTables are not harmonic Save anymore and are needed to rebuild... pls stay save later!
+    if (AudioConfig::getInstance()->isNeedToReInit()) {
+        cleanTables();
+        AudioConfig::getInstance()->setNeedToReInit(false);
+    }
+    if (m_isInit) {
+        return;
+    }
+    m_waveTables[WaveForms::SAW] = new WaveTableGroup();
+    m_waveTables[WaveForms::SINE] = new WaveTableGroup();
+    m_waveTables[WaveForms::SQUARE] = new WaveTableGroup();
+    m_waveTables[WaveForms::TRIANGLE] = new WaveTableGroup();
+    m_waveTables[WaveForms::wSaw] = new WaveTableGroup();
+    m_waveTables[WaveForms::wSQUARE] = new WaveTableGroup();
+    m_waveTables[WaveForms::SYNTHONE] = new WaveTableGroup();
+    m_waveTables[WaveForms::SYNTHTWO] = new WaveTableGroup();
+    m_waveTables[WaveForms::VENOX] = new WaveTableGroup();
+
+    generateSaw(m_waveTables[WaveForms::SAW]);
+    m_isInit = true;
+}
+
+WaveTableGroup *WaveTableGenerator::getGroup(int id) {
+    if (!m_isInit) {
+        init();
+    }
+    if (id < 40) {
+        return m_waveTables[id];
+    }
+    return nullptr;
+}
+
+void WaveTableGenerator::cleanTables() {
+    for (auto & m_waveTable : m_waveTables) {
+        delete m_waveTable;
+    }
+    m_isInit = false;
+}

Source/Veno/Audio/WaveTable/WaveTableGenerator.h

@@ -0,0 +1,53 @@
+//
+// Created by versustune on 08.06.20.
+//
+
+#ifndef VENO_WAVETABLEGENERATOR_H
+#define VENO_WAVETABLEGENERATOR_H
+
+struct WaveTableObject {
+    double m_topFreq;
+    int m_waveTableLen;
+    float *m_waveTable;
+};
+
+struct WaveTableGroup {
+    static constexpr int numWaveTableSlots = 40;
+    WaveTableObject *m_WaveTables[numWaveTableSlots] = {};
+    int m_numWaveTables = 0;
+};
+
+enum WaveForms {
+    SAW = 0,
+    SINE,
+    SQUARE,
+    TRIANGLE,
+    wSaw,
+    wSQUARE, //that stuff is to dirty xD,
+    SYNTHONE,
+    SYNTHTWO,
+    VENOX
+};
+
+class WaveTableGenerator {
+private:
+    static constexpr int numWaveTableSlots = 40;
+    WaveTableGroup *m_waveTables[numWaveTableSlots] = {};
+public:
+    static WaveTableGenerator &getInstance() {
+        static WaveTableGenerator instance;
+        return instance;
+    }
+    WaveTableGroup *getGroup(int id);
+    void init();
+
+    void cleanTables();
+
+protected:
+    bool m_isInit = false;
+    WaveTableGenerator() = default;
+    ~WaveTableGenerator() = default;
+};
+
+
+#endif //VENO_WAVETABLEGENERATOR_H

Source/Veno/Audio/WaveTable/WavesInlcuder.h

@@ -0,0 +1,6 @@
+#include "TableHelper.h"
+#include "SawWaves.h"
+#include "SineWaves.h"
+#include "SquareWaves.h"
+#include "TriangleWaves.h"
+#include "VeNoXWaves.h"