fix: asserts && current note pointer

.clang-format

@@ -1,216 +0,0 @@
----
-Language:        Cpp
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -2
-AlignAfterOpenBracket: Align
-AlignArrayOfStructures: None
-AlignConsecutiveAssignments:
-  Enabled:         false
-  AcrossEmptyLines: false
-  AcrossComments:  false
-  AlignCompound:   false
-  PadOperators:    true
-AlignConsecutiveBitFields:
-  Enabled:         false
-  AcrossEmptyLines: false
-  AcrossComments:  false
-  AlignCompound:   false
-  PadOperators:    false
-AlignConsecutiveDeclarations:
-  Enabled:         false
-  AcrossEmptyLines: false
-  AcrossComments:  false
-  AlignCompound:   false
-  PadOperators:    false
-AlignConsecutiveMacros:
-  Enabled:         false
-  AcrossEmptyLines: false
-  AcrossComments:  false
-  AlignCompound:   false
-  PadOperators:    false
-AlignEscapedNewlines: Right
-AlignOperands:   Align
-AlignTrailingComments: true
-AllowAllArgumentsOnNextLine: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortEnumsOnASingleLine: true
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: All
-AllowShortLambdasOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: MultiLine
-AttributeMacros:
-  - __capability
-BinPackArguments: true
-BinPackParameters: true
-BraceWrapping:
-  AfterCaseLabel:  false
-  AfterClass:      false
-  AfterControlStatement: Never
-  AfterEnum:       false
-  AfterFunction:   false
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     false
-  AfterUnion:      false
-  AfterExternBlock: false
-  BeforeCatch:     false
-  BeforeElse:      false
-  BeforeLambdaBody: false
-  BeforeWhile:     false
-  IndentBraces:    false
-  SplitEmptyFunction: true
-  SplitEmptyRecord: true
-  SplitEmptyNamespace: true
-BreakBeforeBinaryOperators: None
-BreakBeforeConceptDeclarations: Always
-BreakBeforeBraces: Attach
-BreakBeforeInheritanceComma: false
-BreakInheritanceList: BeforeColon
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakConstructorInitializers: BeforeColon
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     80
-CommentPragmas:  '^ IWYU pragma:'
-QualifierAlignment: Leave
-CompactNamespaces: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DeriveLineEnding: true
-DerivePointerAlignment: false
-DisableFormat:   false
-EmptyLineAfterAccessModifier: Never
-EmptyLineBeforeAccessModifier: LogicalBlock
-ExperimentalAutoDetectBinPacking: false
-PackConstructorInitializers: BinPack
-BasedOnStyle:    ''
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-AllowAllConstructorInitializersOnNextLine: true
-FixNamespaceComments: true
-ForEachMacros:
-  - foreach
-  - Q_FOREACH
-  - BOOST_FOREACH
-IfMacros:
-  - KJ_IF_MAYBE
-IncludeBlocks:   Preserve
-IncludeCategories:
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-    Priority:        2
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
-    Priority:        3
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '.*'
-    Priority:        1
-    SortPriority:    0
-    CaseSensitive:   false
-IncludeIsMainRegex: '(Test)?$'
-IncludeIsMainSourceRegex: ''
-IndentAccessModifiers: false
-IndentCaseLabels: true
-IndentCaseBlocks: false
-IndentGotoLabels: true
-IndentPPDirectives: None
-IndentExternBlock: AfterExternBlock
-IndentRequiresClause: true
-IndentWidth: 4
-IndentWrappedFunctionNames: false
-InsertBraces:    false
-InsertTrailingCommas: None
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-LambdaBodyIndentation: Signature
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBinPackProtocolList: Auto
-ObjCBlockIndentWidth: 2
-ObjCBreakBeforeNestedBlockParam: true
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakOpenParenthesis: 0
-PenaltyBreakString: 1000
-PenaltyBreakTemplateDeclaration: 10
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PenaltyIndentedWhitespace: 0
-PointerAlignment: Left
-PPIndentWidth:   -1
-ReferenceAlignment: Pointer
-ReflowComments:  true
-RemoveBracesLLVM: false
-RequiresClausePosition: OwnLine
-SeparateDefinitionBlocks: Leave
-ShortNamespaceLines: 1
-SortIncludes:    CaseSensitive
-SortJavaStaticImport: Before
-SortUsingDeclarations: true
-SpaceAfterCStyleCast: false
-SpaceAfterLogicalNot: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCaseColon: false
-SpaceBeforeCpp11BracedList: false
-SpaceBeforeCtorInitializerColon: true
-SpaceBeforeInheritanceColon: true
-SpaceBeforeParens: ControlStatements
-SpaceBeforeParensOptions:
-  AfterControlStatements: true
-  AfterForeachMacros: true
-  AfterFunctionDefinitionName: false
-  AfterFunctionDeclarationName: false
-  AfterIfMacros:   true
-  AfterOverloadedOperator: false
-  AfterRequiresInClause: false
-  AfterRequiresInExpression: false
-  BeforeNonEmptyParentheses: false
-SpaceAroundPointerQualifiers: Default
-SpaceBeforeRangeBasedForLoopColon: true
-SpaceInEmptyBlock: false
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  Never
-SpacesInConditionalStatement: false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInLineCommentPrefix:
-  Minimum:         1
-  Maximum:         -1
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-SpaceBeforeSquareBrackets: false
-BitFieldColonSpacing: Both
-Standard:        Latest
-StatementAttributeLikeMacros:
-  - Q_EMIT
-StatementMacros:
-  - Q_UNUSED
-  - QT_REQUIRE_VERSION
-TabWidth:        8
-UseCRLF:         false
-UseTab:          Never
-WhitespaceSensitiveMacros:
-  - STRINGIZE
-  - PP_STRINGIZE
-  - BOOST_PP_STRINGIZE
-  - NS_SWIFT_NAME
-  - CF_SWIFT_NAME
-...
-

.vscode/launch.json

@@ -1,16 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug",
-            "program": "${workspaceFolder}/bin/main",
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        }
-    ]
-}

.vscode/settings.json

@@ -7,64 +7,7 @@
         "__bit_reference": "c",
         "bitset": "c",
         "chrono": "c",
-        "unordered_map": "c",
-        "__bits": "cpp",
-        "__config": "cpp",
-        "__debug": "cpp",
-        "__errc": "cpp",
-        "__hash_table": "cpp",
-        "__locale": "cpp",
-        "__mutex_base": "cpp",
-        "__node_handle": "cpp",
-        "__split_buffer": "cpp",
-        "__threading_support": "cpp",
-        "__tuple": "cpp",
-        "__verbose_abort": "cpp",
-        "array": "cpp",
-        "atomic": "cpp",
-        "bit": "cpp",
-        "cctype": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "complex": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "exception": "cpp",
-        "initializer_list": "cpp",
-        "ios": "cpp",
-        "iosfwd": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "locale": "cpp",
-        "memory": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "optional": "cpp",
-        "ostream": "cpp",
-        "ratio": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "string": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "typeinfo": "cpp",
-        "variant": "cpp",
-        "vector": "cpp",
-        "__nullptr": "cpp",
-        "__string": "cpp",
-        "compare": "cpp",
-        "concepts": "cpp",
-        "numeric": "cpp"
+        "unordered_map": "c"
     },
     "FSharp.suggestGitignore": false,
 }

.vscode/tasks.json

@@ -3,12 +3,24 @@
         {
             "type": "cppbuild",
             "label": "C/C++: clang сборка активного файла",
-            "command": "sh",
+            "command": "/usr/bin/clang",
             "args": [
-                "${workspaceFolder}/build.sh"
+                "-fcolor-diagnostics",
+                "-fansi-escape-codes",
+                "-g",
+                "${file}",
+                "${fileDirname}/utils.c",
+                "${fileDirname}/ring_buffer.c",
+                "${fileDirname}/oscillator.c",
+                "${fileDirname}/parser.c",
+                "${fileDirname}/export.c",
+                "-lm",
+                "-lraylib",
+                "-o",
+                "${fileDirname}/bin/${fileBasenameNoExtension}"
             ],
             "options": {
-                "cwd": "${workspaceFolder}"
+                "cwd": "${fileDirname}"
             },
             "problemMatcher": [
                 "$gcc"

build.sh

@@ -1,5 +1,3 @@
 #!/bin/bash
-CC="${CXX:-c++}"
-LL="-lm -lraylib"
-FLAGS="-Wall -std=c++17 -I./inc/ -g"
-$CC $FLAGS $(find ./src -type f -iregex ".*\.cpp") $LL -o ./bin/main
+CC="${CXX:-cc}"
+$CC -Wall -std=c11 ./main.c ./utils.c ./ring_buffer.c ./oscillator.c ./parser.c ./export.c -lm -lraylib -o ./bin/main

docs/ADSR.md

@@ -26,7 +26,6 @@ release_samples = int(release_time * sample_rate)
 
 # Attack phase
 envelope[:attack_samples] = np.linspace(0, 1, num=attack_samples)
-# 1/n * count;
 
 # Decay phase
 decay_slope = (1 - sustain_level) / decay_samples

export.c

@@ -0,0 +1,74 @@
+#include "export.h"
+
+#include "stdio.h"
+#include "string.h"
+#include "settings.h"
+
+uint16_t toInt16Sample(float sample) {
+    return (uint16_t)(sample * 32767.f);
+}
+
+static void write_file(char* filename, void* data, int size) {
+    FILE* fp = fopen(filename, "wb");  // open file for writing in binary mode
+    if (fp == NULL) {
+        fprintf(stderr, "Cannot open file: %s\n", filename);
+        exit(1);
+    }
+
+    fwrite(data, size, 1, fp);  // write data to file
+
+    fclose(fp);  // close file
+}
+
+void pack(uint16_t* d, size_t length) {
+    size_t dataLength = length * 2;
+
+    int bytesPerSample = 2;
+    int byteRate = SAMPLE_RATE * bytesPerSample;
+
+    size_t fileSize = 36 + dataLength;
+
+    uint8_t* buffer = (uint8_t*)malloc(fileSize);
+
+    int i = 0;
+
+    // RIFF header
+    memcpy(buffer + i, "RIFF", 4);
+    i += 4;
+    memcpy(buffer + i, &fileSize, 4);
+    i += 4;
+    memcpy(buffer + i, "WAVE", 4);
+    i += 4;
+
+    // fmt subchunk
+    memcpy(buffer + i, "fmt ", 4);
+    i += 4;
+    int fmtSize = 16;
+    memcpy(buffer + i, &fmtSize, 4);
+    i += 4;
+    uint16_t audioFormat = 1;
+    memcpy(buffer + i, &audioFormat, 2);
+    i += 2;
+    uint16_t numChannels = 1;
+    memcpy(buffer + i, &numChannels, 2);
+    i += 2;
+    int sampleRate = (int)SAMPLE_RATE;
+    memcpy(buffer + i, &sampleRate, 4);
+    i += 4;
+    memcpy(buffer + i, &byteRate, 4);
+    i += 4;
+    memcpy(buffer + i, &bytesPerSample, 2);
+    i += 2;
+    int bitsPerSample = bytesPerSample * 8;
+    memcpy(buffer + i, &bitsPerSample, 2);
+    i += 2;
+
+    // data subchunk
+    memcpy(buffer + i, "data", 4);
+    i += 4;
+    memcpy(buffer + i, &dataLength, 4);
+    i += 4;
+    memcpy(buffer + i, d, dataLength);
+
+    write_file("output.wav", buffer, fileSize);
+}

export.h

@@ -0,0 +1,9 @@
+#ifndef EXPORT_H
+#define EXPORT_H
+
+#include "stdlib.h"
+
+uint16_t toInt16Sample(float sample);
+void pack(uint16_t* d, size_t length);
+
+#endif

inc/ADSR.h

@@ -1,30 +0,0 @@
-#pragma once
-#include "Effect.h"
-#include "Ramp.h"
-#include <cstddef>
-
-class ADSR : public Effect {
-    enum ADSRState { sOff, sAttack, sDecay, sSustain, sRelease };
-
-  private:
-    float m_attack_time;
-    float m_decay_time;
-    float m_sustain_level;
-    float m_release_time;
-    ADSRState m_state;
-    Ramp* m_ramp;
-
-    void process_sample(float* sample);
-    bool is_attack_elapsed();
-    bool is_decay_elapsed();
-    bool is_release_elapsed();
-    void recheck_state();
-
-  public:
-    ADSR(/* args */);
-    ~ADSR();
-    void Trigger() override;
-    void Release() override;
-    void Process(std::vector<float>& samples) override;
-    void SetParameters(float attack, float decay, float sustain, float release);
-};

inc/Adder.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "Oscillator.h"
-#include "Settings.h"
-#include <numeric>
-#include <vector>
-
-struct Adder {
-    static void SumOscillators(const std::vector<Oscillator*>& oscillators,
-                               std::vector<float>& signal) {
-        size_t sample_count = STREAM_BUFFER_SIZE;
-
-        for (size_t i = 0; i < sample_count; i++) {
-            float sample = 0.0f;
-            for (Oscillator* osc : oscillators) {
-                sample += osc->Process();
-            }
-
-            signal[i] = sample;
-        }
-    }
-};

inc/Application.h

@@ -1,26 +0,0 @@
-#pragma once
-#include "Note.h"
-#include "Renderer.h"
-#include "Synth.h"
-#include "SynthGuiState.h"
-#include "raylib.h"
-
-class Application {
-  private:
-    Synth m_synth;
-    SynthGuiState m_synth_gui_state;
-    AudioStream m_synth_stream;
-    int m_sound_played_count;
-    Note* m_current_note;
-    Renderer m_renderer;
-    bool DetectNotePressed(Note* note);
-    void InitSynth();
-    void InitAudio();
-    void UpdateOnNoteInput();
-    void PlayBufferedAudio();
-
-  public:
-    Application(/* args */);
-    ~Application();
-    void Run();
-};

inc/BandPassFilter.h

@@ -1,14 +0,0 @@
-#pragma once
-#include "Filter.h"
-
-class BandPassFilter : public Filter {
-  private:
-    void CalculateCoefficients() override;
-
-  public:
-    BandPassFilter(Filter* filter);
-    BandPassFilter(float freq, float res, float q);
-    BandPassFilter(/* args */);
-    ~BandPassFilter();
-    bool IsSameFilterType(FilterType type) override { return type == BandPass; };
-};

inc/Effect.h

@@ -1,12 +0,0 @@
-#pragma once
-#include <vector>
-class Effect {
-  private:
-    /* data */
-  public:
-    Effect(/* args */){};
-    ~Effect(){};
-    virtual void Trigger(){};
-    virtual void Release(){};
-    virtual void Process(std::vector<float>& samples){};
-};

inc/Filter.h

@@ -1,35 +0,0 @@
-#pragma once
-#include "Effect.h"
-
-enum FilterType {
-    LowPass,
-    BandPass,
-    HighPass
-};
-
-class Filter : public Effect {
-  protected:
-    float m_freq;  // cutoff frequency
-    float m_q;     // filter quantity (resonance)
-    float m_order; // filter order (peakGain)
-    /* todo: filter adsr */
-    float m_norm, m_v, m_k;
-    float m_a0, m_a1, m_a2, m_b1, m_b2;
-    float m_z1, m_z2;
-
-    void CalculateNormals();
-    virtual void CalculateCoefficients(){};
-
-  public:
-    Filter(/* args */);
-    virtual ~Filter();
-    void Trigger() override;
-    void Release() override;
-    float Process(float in);
-    void Process(std::vector<float>& samples) override;
-    void SetParameters(float freq, float res, float q);
-    float GetFreq() { return m_freq; }
-    float GetRes() { return m_q; }
-    float GetPeakGain() { return m_norm; }
-    virtual bool IsSameFilterType(FilterType type){ return false; };
-};

inc/FilterFactory.h

@@ -1,29 +0,0 @@
-#pragma once
-#include "Filter.h"
-#include "LowPassFilter.h"
-#include "BandPassFilter.h"
-#include "HighPassFilter.h"
-
-struct FilterFactory {
-    static Filter* CreateFilter(Filter* old_filter, FilterType new_type) {
-        Filter* new_filter;
-        switch (new_type) {
-        case LowPass:
-            new_filter = new LowPassFilter(old_filter);
-            break;
-        case BandPass:
-            new_filter = new BandPassFilter(old_filter);
-            break;
-        case HighPass:
-            new_filter = new HighPassFilter(old_filter);
-            break;
-        default:
-            break;
-        }
-        return new_filter;
-    }
-
-    static Filter* GetDefaultFilter() {
-        return new LowPassFilter();
-    }
-};

inc/HighPassFilter.h

@@ -1,14 +0,0 @@
-#pragma once
-#include "Filter.h"
-
-class HighPassFilter : public Filter {
-  private:
-    void CalculateCoefficients() override;
-
-  public:
-    HighPassFilter();
-    HighPassFilter(Filter* filter);
-    HighPassFilter(float freq, float res, float q);
-    ~HighPassFilter();
-    bool IsSameFilterType(FilterType type) override { return type == HighPass; };
-};

inc/KeyBoard.h

@@ -1,77 +0,0 @@
-#pragma once
-#include "Settings.h"
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <string>
-
-class KeyBoard {
-  private:
-    static int GetSemitoneShiftInternal(const char* root_note,
-                                           char* target_note) {
-        const char* pitch_classes[12] = {"C",  "C#", "D",  "D#", "E",  "F",
-                                         "F#", "G",  "G#", "A",  "A#", "B"};
-
-        // Extract the note number and pitch class for the root note
-        int root_note_num = (int)root_note[strlen(root_note) - 1] - '0';
-
-        char* root_pitch_class_str =
-            (char*)malloc((strlen(root_note) - 1) * sizeof(char));
-        strncpy(root_pitch_class_str, root_note, strlen(root_note) - 1);
-
-        int root_pitch_class = -1;
-
-        for (int i = 0; i < 12; i++) {
-            if (strcmp(pitch_classes[i], root_pitch_class_str) == 0) {
-                root_pitch_class = i;
-                break;
-            }
-        }
-
-        free(root_pitch_class_str);
-
-        // Extract the note number and pitch class for the target note
-        int target_note_num = (int)target_note[strlen(target_note) - 1] - '0';
-
-        char* target_pitch_class_str =
-            (char*)malloc((strlen(target_note) - 1) * sizeof(char));
-        strncpy(target_pitch_class_str, target_note, strlen(target_note) - 1);
-
-        int target_pitch_class = -1;
-
-        for (int i = 0; i < 12; i++) {
-            if (strcmp(pitch_classes[i], target_pitch_class_str) == 0) {
-                target_pitch_class = i;
-                break;
-            }
-        }
-
-        free(target_pitch_class_str);
-
-        // Calculate the semitone shift using the formula
-        return (target_note_num - root_note_num) * 12 +
-               (target_pitch_class - root_pitch_class);
-    }
-
-  public:
-    KeyBoard(/* args */);
-    ~KeyBoard();
-
-    static float GetHzBySemitone(int semitone) {
-        return PITCH_STANDARD * powf(powf(2.f, (1.f / 12.f)), semitone);
-    }
-
-    static int GetSemitoneShift(const std::string& target_note) {
-        char* target_note_cstr = new char[target_note.length() + 1];
-        strcpy(target_note_cstr, target_note.c_str());
-
-        int result = GetSemitoneShiftInternal("A4", target_note_cstr);
-
-        delete[] target_note_cstr;
-        return result;
-    }
-};
-
-KeyBoard::KeyBoard(/* args */) {}
-
-KeyBoard::~KeyBoard() {}

inc/Logger.h

@@ -1,7 +0,0 @@
-#pragma once
-#include "cstdio"
-
-#define write_log(format, args...)                                             \
-    do {                                                                       \
-        printf(format, ##args);                                                \
-    } while (0)

inc/LowPassFilter.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "Filter.h"
-
-class LowPassFilter : public Filter {
-  protected:
-    void CalculateCoefficients() override;
-
-  public:
-    LowPassFilter();
-    LowPassFilter(Filter* filter);
-    LowPassFilter(float freq, float res, float q);
-    ~LowPassFilter();
-    bool IsSameFilterType(FilterType type) override { return type == LowPass; };
-};

inc/Note.h

@@ -1,8 +0,0 @@
-#pragma once
-
-#include <string>
-
-struct Note {
-    std::string& name;
-    int length;
-};

inc/Oscillator.h

@@ -1,35 +0,0 @@
-#pragma once
-#include "OscillatorType.h"
-#include <vector>
-
-class Oscillator {
-  private:
-    OscillatorType m_osc;
-    float m_freq;
-    float m_volume;
-    float m_phase;
-    float m_phase_dt;
-    float (Oscillator::*m_osc_function)(void);
-    float (Oscillator::*m_dt_function)(float freq);
-    void sine_osc_phase_incr();
-    void saw_osc_phase_incr();
-    float calc_saw_phase_delta(float freq);
-    float calc_sine_phase_delta(float freq);
-    float sawosc();
-    float triangleosc();
-    float squareosc();
-    float sign(float v);
-    float sineosc();
-
-  public:
-    Oscillator(OscillatorType osc, float freq, float volume);
-    ~Oscillator();
-    OscillatorType GetType() { return m_osc; }
-    void SetType(OscillatorType osc);
-    float GetVolume() { return m_volume; }
-    void SetVolume(float volume) { m_volume = volume; }
-    float GetFreq() { return m_freq; }
-    void SetFreq(float freq);
-    void Reset();
-    float Process();
-};

inc/OscillatorType.h

@@ -1,2 +0,0 @@
-#pragma once
-typedef enum { Sine, Triangle, Saw, Square } OscillatorType;

inc/Ramp.h

@@ -1,16 +0,0 @@
-#pragma once
-
-class Ramp {
-  private:
-    float m_level;
-    float m_sample_rate;
-    float m_increment;
-    int m_counter;
-
-  public:
-    Ramp(float starting_level, float sample_rate);
-    ~Ramp();
-    void RampTo(float value, float time);
-    float Process();
-    bool IsCompleted();
-};

inc/Renderer.h

@@ -1,31 +0,0 @@
-#pragma once
-#include "ADSR.h"
-#include "Filter.h"
-#include "Synth.h"
-#include "SynthGuiState.h"
-#include "raylib.h"
-#include <vector>
-
-class Renderer {
-  private:
-    void draw_main_panel(const Rectangle& panel_bounds);
-    float draw_oscillators_panels(
-        const std::vector<Oscillator*>& oscillators,
-        const std::vector<OscillatorGuiState*>& gui_oscillators,
-        const Rectangle& panel_bounds);
-    void draw_oscillators_shape_inputs(
-        const std::vector<Oscillator*>& oscillators,
-        const std::vector<OscillatorGuiState*>& guiOscillators);
-    void draw_ui(Synth& synth, SynthGuiState& synth_gui);
-    void draw_signal(Synth& synth, SynthGuiState& synth_gui);
-    void draw_adsr_panel(ADSR* adsr, ADSRGuiState& gui_adsr,
-                         const Rectangle& panel_bounds, float panel_y_offset);
-    void draw_second_panel(Rectangle& bounds);
-    float DrawFilterPanel(Synth& synth, FilterGuiState& gui_filter,
-                            const Rectangle& panel_bounds);
-
-  public:
-    Renderer(/* args */);
-    ~Renderer();
-    void Draw(Synth& synth, SynthGuiState& synth_gui);
-};

inc/RingBuffer.h

@@ -1,115 +0,0 @@
-#pragma once
-#include "Logger.h"
-#include <cstddef>
-template <typename T> class RingBuffer {
-  private:
-    T* m_items; /* data */
-    std::size_t m_head;
-    std::size_t m_tail;
-    bool m_is_full;
-    bool m_is_empty;
-    std::size_t m_size;
-    void advance_pointer();
-    void retreat_pointer();
-
-  public:
-    RingBuffer(std::size_t size);
-    ~RingBuffer();
-    bool IsFull() { return m_is_full; }
-    bool IsEmpty() { return m_is_empty; }
-    std::size_t GetSize();
-    std::size_t GetCapacity() { return m_size; }
-    void Reset();
-    void Write(T* data, size_t count);
-    bool Read(T* output, size_t count);
-    void Print();
-};
-
-template <typename T> RingBuffer<T>::RingBuffer(std::size_t size) {
-    m_items = new T[size];
-    m_head = 0;
-    m_tail = 0;
-    m_is_full = 0;
-    m_is_empty = 1;
-    m_size = size;
-}
-
-template <typename T> RingBuffer<T>::~RingBuffer() { delete[] m_items; }
-
-template <typename T> void RingBuffer<T>::Reset() {
-    m_head = 0;
-    m_tail = 0;
-    m_is_full = 0;
-}
-
-template <typename T> void RingBuffer<T>::advance_pointer() {
-    if (m_is_full) {
-        m_tail++;
-        if (m_tail == m_size) {
-            m_tail = 0;
-        }
-    }
-    m_head++;
-    if (m_head == m_size) {
-        m_head = 0;
-    }
-    std::size_t p_is_full = m_head == m_tail ? 1 : 0;
-    m_is_full = p_is_full;
-}
-
-template <typename T> void RingBuffer<T>::retreat_pointer() {
-    m_is_full = 0;
-    m_tail++;
-    if (m_tail == m_size) {
-        m_tail = 0;
-    }
-}
-
-template <typename T> void RingBuffer<T>::Write(T* data, std::size_t count) {
-    if (m_is_full || m_head + count > m_size) {
-        write_log("[WARN] Trying to overfill the ring buffer: "
-                  "\n\tIsFull:%d\n\tHead:%zu\n\tCount:%zu\n\t",
-                  m_is_full, m_head, count);
-        return;
-    }
-    m_is_empty = 0;
-
-    for (std::size_t i = 0; i < count; i++) {
-        m_items[m_head] = data[i];
-        advance_pointer();
-    }
-    // m_is_empty = m_is_full && (m_head == m_tail);
-}
-
-template <typename T> bool RingBuffer<T>::Read(T* output, std::size_t count) {
-    if (m_is_empty) {
-        write_log("[WARN] Trying to read empty buffer");
-        return 0;
-    }
-
-    for (std::size_t i = 0; i < count; i++) {
-        output[i] = m_items[m_tail];
-        retreat_pointer();
-    }
-    m_is_empty = !m_is_full && (m_head == m_tail);
-    return 1;
-}
-
-template <typename T> std::size_t RingBuffer<T>::GetSize() {
-    size_t p_size = m_size;
-    if (!m_is_full) {
-        if (m_head >= m_tail) {
-            p_size = (m_head - m_tail);
-        } else {
-            p_size = (m_size + m_head - m_tail);
-        }
-    }
-
-    return p_size;
-}
-
-template <typename T> void RingBuffer<T>::Print() {
-    write_log("[INFO] The ring buffer: "
-              "\n\tIsFull:%d\n\tIsEmpty:%d\n\tHead:%zu\n\tTail:%zu\n\t",
-              m_is_full, m_is_empty, m_head, m_tail);
-}

inc/Synth.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include "ADSR.h"
-#include "Filter.h"
-#include "Adder.h"
-#include "Effect.h"
-#include "Note.h"
-#include "Oscillator.h"
-#include "Settings.h"
-#include <vector>
-
-class Synth {
-  private:
-    bool is_note_triggered;
-    std::vector<Oscillator*> m_oscillators;
-    std::vector<Effect*> m_effects;
-    std::vector<float> m_out_signal;
-    Oscillator* m_lfo;
-    void zero_signal();
-    void get_note();
-    void trigger_note_on_effects();
-    void untrigger_note_on_effects();
-    void apply_effects();
-    void add_oscillator();
-    void apply_filter_lfo();
-  public:
-    Synth(/* args */);
-    ~Synth();
-    void Trigger(Note input);
-    void Process();
-    void Release();
-    void AddEffect(Effect* fx);
-    const std::vector<float>& GetOutSignal() { return m_out_signal; }
-    const std::vector<Oscillator*>& GetOscillators() { return m_oscillators; }
-    const bool& GetIsNoteTriggered() { return is_note_triggered; }
-    ADSR* GetADSR() { return (ADSR*)m_effects[0]; }
-    Filter* GetFilter() { return (Filter*)m_effects[1]; }
-    void SetFilter(FilterType type);
-};

inc/SynthGuiState.h

@@ -1,33 +0,0 @@
-#pragma once
-#include "OscillatorType.h"
-#include "raygui.h"
-#include <vector>
-#include "Filter.h"
-
-struct OscillatorGuiState {
-    float volume;
-    float freq; // todo: remove or change to pitch shift
-    OscillatorType waveshape;
-    bool is_dropdown_open;
-    Rectangle shape_dropdown_rect;
-};
-
-struct ADSRGuiState {
-    float attack;
-    float decay;
-    float sustain;
-    float release;
-};
-
-struct FilterGuiState {
-    float freq;
-    float res; //todo: res
-    FilterType type;
-    bool is_dropdown_open;
-};
-
-struct SynthGuiState {
-    std::vector<OscillatorGuiState*> oscillators;
-    ADSRGuiState adsr;
-    FilterGuiState filter;
-};

main.c

@@ -0,0 +1,471 @@
+#include "stdlib.h"
+#include "stdio.h"
+#include "string.h"
+#include "math.h"
+
+#include "parser.h"
+#include "utils.h"
+#include "ring_buffer.h"
+#include "settings.h"
+#include "oscillator.h"
+#include "export.h"
+
+#include "raylib.h"
+#define RAYGUI_IMPLEMENTATION
+#include "raygui.h"
+
+//------------------------------------------------------------------------------------
+// Synth
+//------------------------------------------------------------------------------------
+
+typedef struct OscillatorUI {
+    float volume;
+    float freq;//todo: remove or change to pitch shift
+    OscillatorType waveshape;
+    bool is_dropdown_open;
+    Rectangle shape_dropdown_rect;
+} OscillatorUI;
+
+typedef struct Synth {
+    OscillatorArray oscillators;
+    OscillatorUI* ui_oscillators;
+    Note current_note;
+    SynthSound* out_signal;
+} Synth;
+
+static int get_semitone_shift_internal(char* root_note, char* target_note) {
+    char* pitch_classes[12] =
+        { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
+
+    // Extract the note number and pitch class for the root note
+    int root_note_num = (int)root_note[strlen(root_note) - 1] - '0';
+
+    char* root_pitch_class_str = malloc((strlen(root_note) - 1) * sizeof(char));
+    strncpy(root_pitch_class_str, root_note, strlen(root_note) - 1);
+
+    int root_pitch_class = -1;
+
+    for (int i = 0; i < 12; i++) {
+        if (strcmp(pitch_classes[i], root_pitch_class_str) == 0) {
+            root_pitch_class = i;
+            break;
+        }
+    }
+
+    free(root_pitch_class_str);
+
+    // Extract the note number and pitch class for the target note
+    int target_note_num = (int)target_note[strlen(target_note) - 1] - '0';
+
+    char* target_pitch_class_str =
+        malloc((strlen(target_note) - 1) * sizeof(char));
+    strncpy(target_pitch_class_str, target_note, strlen(target_note) - 1);
+
+    int target_pitch_class = -1;
+
+    for (int i = 0; i < 12; i++) {
+        if (strcmp(pitch_classes[i], target_pitch_class_str) == 0) {
+            target_pitch_class = i;
+            break;
+        }
+    }
+
+    free(target_pitch_class_str);
+
+    // Calculate the semitone shift using the formula
+    return (target_note_num - root_note_num) * 12 +
+        (target_pitch_class - root_pitch_class);
+}
+
+static float get_hz_by_semitone(int semitone) {
+    return PITCH_STANDARD * powf(powf(2.f, (1.f / 12.f)), semitone);
+}
+
+int get_semitone_shift(char* target_note) {
+    return get_semitone_shift_internal("A4", target_note);
+}
+
+static OscillatorArray init_osc_array() {
+    Oscillator first = {
+        .osc = Square,
+        .freq = 440.f,
+        .volume = VOLUME
+    };
+
+    Oscillator* oscArray = malloc(sizeof(Oscillator*) * 1);
+    assert(oscArray);
+    
+    oscArray[0] = first;
+
+    OscillatorArray oscillators = {
+        .array = oscArray,
+        .count = 1
+    };
+
+    return oscillators;
+}
+
+SynthSound note(Synth* synth, int semitone, float beats) {
+    float hz = get_hz_by_semitone(semitone);
+    float duration = beats * BEAT_DURATION;
+    
+    // will change after oscillator starts to be more autonomous
+    for (size_t i = 0; i < synth->oscillators.count; i++) {
+        osc_set_freq(&synth->oscillators.array[i], hz);
+    }
+
+    return freq(duration, synth->oscillators);
+}
+
+SynthSound get_note_sound(Synth* synth, Note input) {
+    float length = 1.f / input.length;
+    int semitone_shift = get_semitone_shift(input.name);
+    return note(synth, semitone_shift, length);
+}
+//-------------------------------------------------------
+
+size_t detect_note_pressed(Note* note) {
+    size_t is_pressed = 0;
+    note->length = 8;
+    if (IsKeyPressed(KEY_A)) {
+        strcpy(note->name, "A4");
+        is_pressed = 1;
+    }
+    if (IsKeyPressed(KEY_B)) {
+        strcpy(note->name, "B4");
+        is_pressed = 1;
+    }
+    if (IsKeyPressed(KEY_C)) {
+        strcpy(note->name, "C4");
+        is_pressed = 1;
+    }
+    if (IsKeyPressed(KEY_D)) {
+        strcpy(note->name, "D4");
+        is_pressed = 1;
+    }
+    if (IsKeyPressed(KEY_E)) {
+        strcpy(note->name, "E4");
+        is_pressed = 1;
+    }
+    if (IsKeyPressed(KEY_F)) {
+        strcpy(note->name, "F4");
+        is_pressed = 1;
+    }
+    if (IsKeyPressed(KEY_G)) {
+        strcpy(note->name, "G4");
+        is_pressed = 1;
+    }
+    return is_pressed;
+}
+
+//------------------------------------------------------------------------------------
+// GUI
+//------------------------------------------------------------------------------------
+
+void note_on(Synth *synth, Note *note) {
+	
+}
+
+void DrawUi(Synth *synth) {
+    const int panel_x_start = 0;
+    const int panel_y_start = 0;
+    const int panel_width = OSCILLATOR_PANEL_WIDTH;
+    const int panel_height = WINDOW_HEIGHT;
+    
+    bool is_shape_dropdown_open = false;
+    int shape_index = 0;
+    
+    
+    GuiPanel((Rectangle){
+                 panel_x_start,
+                 panel_y_start,
+                 panel_width,
+                 panel_height
+             }, 
+            "");
+    
+    bool click_add_oscillator = GuiButton((Rectangle){
+                                              panel_x_start + 10,
+                                              panel_y_start + 10,
+                                              panel_width - 20,
+                                              25
+                                          }, "Add Oscillator");
+    if (click_add_oscillator)
+    {
+        // synth->ui_oscillator_count += 1;
+        // // Set defaults:
+        // UiOscillator *ui_osc = synth->ui_oscillator + (synth->ui_oscillator_count - 1);
+        // ui_osc->shape = WaveShape_SINE;
+        // ui_osc->freq = BASE_NOTE_FREQ;
+        // ui_osc->amplitude_ratio = 0.1f;
+        // ui_osc->shape_parameter_0 = 0.5f;
+    }
+
+    // Draw Oscillators
+    float panel_y_offset = 0;
+    //synth->ui_oscillator_count = 1
+    for (int ui_osc_i = 0; ui_osc_i < synth->oscillators.count; ui_osc_i++)
+    {
+        OscillatorUI* ui_osc = &synth->ui_oscillators[ui_osc_i];
+        assert(ui_osc);
+
+        Oscillator* osc = &synth->oscillators.array[ui_osc_i];
+        assert(osc);
+
+        const bool has_shape_param = (ui_osc->waveshape == Square);
+        
+        // Draw Oscillator Panel
+        const int osc_panel_width = panel_width - 20;
+        const int osc_panel_height = has_shape_param ? 130 : 100;
+        const int osc_panel_x = panel_x_start + 10;
+        const int osc_panel_y = panel_y_start + 50 + panel_y_offset;
+        panel_y_offset += osc_panel_height + 5;
+        GuiPanel((Rectangle){
+                     osc_panel_x,
+                     osc_panel_y,
+                     osc_panel_width,
+                     osc_panel_height
+                 },
+                "");
+        
+        const float slider_padding = 50.f;
+        const float el_spacing = 5.f;
+        Rectangle el_rect = {
+            .x = osc_panel_x + slider_padding + 30,
+            .y = osc_panel_y + 10,
+            .width = osc_panel_width - (slider_padding * 2),
+            .height = 25
+        };
+        
+        // Volume slider
+        float decibels = (20.f * log10f(osc->volume));
+        char amp_slider_label[32];
+        sprintf(amp_slider_label, "%.1f dB", decibels);
+        decibels = GuiSlider(el_rect, 
+                             amp_slider_label, 
+                             "", 
+                             decibels, 
+                             -60.0f, 
+                             0.0f
+                             );
+        ui_osc->volume = powf(10.f, decibels * (1.f/20.f));
+        osc->volume = ui_osc->volume;
+
+        el_rect.y += el_rect.height + el_spacing;
+        
+        // Defer shape drop-down box.
+        ui_osc->shape_dropdown_rect = el_rect;
+        el_rect.y += el_rect.height + el_spacing;
+        /*
+        Rectangle delete_button_rect = el_rect;
+        delete_button_rect.x = osc_panel_x + 5;
+        delete_button_rect.y -= el_rect.height + el_spacing;
+        delete_button_rect.width = 30;
+        bool is_delete_button_pressed = GuiButton(delete_button_rect, "X");
+        if (is_delete_button_pressed)
+        {
+            memmove(
+                    synth->ui_oscillator + ui_osc_i, 
+                    synth->ui_oscillator + ui_osc_i + 1, 
+                    (synth->ui_oscillator_count - ui_osc_i) * sizeof(UiOscillator)
+                    );
+            synth->ui_oscillator_count -= 1;
+        }
+        */
+    }
+
+    // DRAW OSCILLATOR SHAPE INPUTS
+    for (int ui_osc_i = 0; ui_osc_i < synth->oscillators.count; ui_osc_i += 1)
+    {
+        OscillatorUI* ui_osc = &synth->ui_oscillators[ui_osc_i];
+        assert(ui_osc);
+
+        Oscillator* osc = &synth->oscillators.array[ui_osc_i];
+        assert(osc);
+
+        // Shape select
+        int shape_index = (int)(ui_osc->waveshape);
+        bool is_dropdown_click = GuiDropdownBox(ui_osc->shape_dropdown_rect, 
+                                                WAVE_SHAPE_OPTIONS, 
+                                                &shape_index, 
+                                                ui_osc->is_dropdown_open
+                                                );
+        
+        if (is_dropdown_click)
+        {
+            ui_osc->is_dropdown_open = !ui_osc->is_dropdown_open;
+            ui_osc->waveshape = (OscillatorType)(shape_index);
+            // APPLY STATE TO REAL OSC
+            osc->osc = (OscillatorType)(shape_index);
+        }
+        if (ui_osc->is_dropdown_open) break;
+    }
+}
+
+void DrawSignal(Synth* synth) {
+    GuiGrid((Rectangle){0, 0, WINDOW_WIDTH, WINDOW_HEIGHT}, "", WINDOW_HEIGHT / 8, 2);
+    Vector2* signal_points = malloc(sizeof(Vector2) * synth->out_signal->sample_count);
+    const float screen_vertical_midpoint = (WINDOW_HEIGHT/2);
+    for (int point_idx = 0; point_idx < synth->out_signal->sample_count; point_idx++)
+    {
+        signal_points[point_idx].x = (float)point_idx + OSCILLATOR_PANEL_WIDTH;
+        signal_points[point_idx].y = screen_vertical_midpoint + (int)(synth->out_signal->samples[point_idx] * 300);
+    }
+    DrawLineStrip(signal_points, synth->out_signal->sample_count, RED);
+}
+
+
+//------------------------------------------------------------------------------------
+// Main
+//------------------------------------------------------------------------------------
+
+int main(int argc, char **argv) {
+    InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SeeSynth - v0.2");
+    SetTargetFPS(60);
+
+    //todo: move that variables to Synth declaration
+    Note g_current_note = {
+        .length = 1,
+        .name = malloc(sizeof(char) * 3)
+    };
+
+    SynthSound g_sound = {
+        .sample_count = 0
+    };
+
+    Synth synth = {
+        .current_note = g_current_note,
+        .out_signal = &g_sound,
+        .oscillators = init_osc_array()
+    };
+    //todo: move somewhere in initialization
+    synth.ui_oscillators = malloc(sizeof(OscillatorUI) * synth.oscillators.count);
+    for (size_t i = 0; i < synth.oscillators.count; i++)
+    {
+        OscillatorUI* ui = &synth.ui_oscillators[i];
+        assert(ui);
+
+        ui->freq = synth.oscillators.array[i].freq;
+        ui->waveshape = synth.oscillators.array[i].osc;
+        ui->volume = synth.oscillators.array[i].volume;
+    }
+    
+    int sound_played_count = 0;
+    float temp_buffer[STREAM_BUFFER_SIZE];
+    RingBuffer ring_buffer = ring_buffer_init(STREAM_BUFFER_SIZE);
+
+    InitAudioDevice();
+    SetMasterVolume(SYNTH_VOLUME);
+    SetAudioStreamBufferSizeDefault(STREAM_BUFFER_SIZE);
+    AudioStream synth_stream = LoadAudioStream(SAMPLE_RATE, sizeof(float) * 8, 1);
+    SetAudioStreamVolume(synth_stream, 0.5f);
+
+    PlayAudioStream(synth_stream);
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update Audio states
+        //----------------------------------------------------------------------------------
+        // Fill ring buffer from current sound
+        SynthSound* sound = synth.out_signal;
+        assert(sound);
+
+        size_t size_for_buffer = 0;
+        if (!ring_buffer.is_full && sound->sample_count != sound_played_count) {
+            write_log("[INFO] IsFull:%d Samples:%zu Played:%d\n", 
+                ring_buffer.is_full, 
+                sound->sample_count, 
+                sound_played_count);
+            
+            // how many samples need write
+            size_t size_to_fill = 0;
+            
+            if ((sound->sample_count - sound_played_count) > ring_buffer.size) {
+                size_to_fill = ring_buffer.size;
+            } else {
+                size_to_fill = sound->sample_count - sound_played_count;
+            }
+
+            write_log("[INFO] SizeToFill:%zu\n", size_to_fill);
+            for (size_t i = 0; i < size_to_fill; i++) {
+                temp_buffer[i] = sound->samples[i];
+            }
+            
+            ring_buffer_write(&ring_buffer, temp_buffer, size_to_fill);
+            sound_played_count += size_to_fill;
+        }
+
+        // Play ring-buffered audio
+        if (IsAudioStreamProcessed(synth_stream) && !ring_buffer.is_empty) {
+                size_t size_to_read = ring_buffer_size(&ring_buffer);
+                
+                write_log("Samples to play:%zu \n", size_to_read);
+                //todo: try to start reading directly from ring buffer, avoiding temp_buffer
+                ring_buffer_read(&ring_buffer, temp_buffer, size_to_read);
+                // can try the SetAudioStreamCallback
+                UpdateAudioStream(synth_stream, temp_buffer, size_to_read);
+                // can overwrite the ring buffer to avoid that
+                if (sound->sample_count == sound_played_count) {
+                    ring_buffer_reset(&ring_buffer);
+                }
+        }
+        //----------------------------------------------------------------------------------
+        
+        // Update On Input
+        //----------------------------------------------------------------------------------
+        Note* current_note = &synth.current_note;
+        if (detect_note_pressed(current_note)) {
+            *sound = get_note_sound(&synth, *current_note);
+            sound_played_count = 0;
+            write_log("Note played: %s\n", current_note->name);
+        }
+        //----------------------------------------------------------------------------------
+ 
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+ 
+            ClearBackground(RAYWHITE);
+            DrawUi(&synth);
+            DrawSignal(&synth);
+            //DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
+            //DrawFPS(0,0);
+ 
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+    
+    char* input = "A4-4 A4-4 A4-4 A4-4 A4-2 A4-4 A4-4 A4-4 A4-4 A4-4 A4-2 D5-4 D5-4 D5-4 D5-4 D5-4 D5-4 D5-2 C5-4 C5-4 C5-4 C5-4 C5-4 C5-4 C5-2 G4-2 ";
+    char* buf = malloc(strlen(input) + 1);
+    strcpy(buf, input);
+
+    NoteArray note_array = parse_notes(buf, strlen(buf));
+    SynthSound* sounds = malloc(sizeof(SynthSound) * note_array.count);
+    assert(sounds);
+
+    for (size_t i = 0; i < note_array.count; i++) {
+        Note note = note_array.notes[i];
+        sounds[i] = get_note_sound(&synth, note);
+    }
+
+    SynthSound song = concat_sounds(sounds, note_array.count);
+    uint16_t* song_pcm = malloc(sizeof(uint16_t) * song.sample_count);
+    assert(song_pcm);
+
+    for (size_t i = 0; i < song.sample_count; i++) {
+        song_pcm[i] = toInt16Sample(song.samples[i]);
+    }
+
+    pack(song_pcm, song.sample_count);
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    StopAudioStream(synth_stream);
+    UnloadAudioStream(synth_stream);    
+    CloseAudioDevice();
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

oscillator.c

@@ -0,0 +1,167 @@
+#include "oscillator.h"
+#include "settings.h"
+#include "math.h"
+#include "stdlib.h"
+
+#define TWO_PI 2*SYNTH_PI
+
+static SynthSound get_init_samples(float duration) {
+    size_t sample_count = (size_t)(duration * SAMPLE_RATE);
+    float* samples = malloc(sizeof(float) * sample_count);
+
+    for (double i = 0.0; i < duration * SAMPLE_RATE; i++) {
+        samples[(int)i] = i;
+    }
+
+    SynthSound res = {
+        .samples = samples,
+        .sample_count = sample_count
+    };
+
+    return res;
+}
+
+static float pos(float hz, float x) {
+    return fmodf(hz * x / SAMPLE_RATE, 1);
+}
+
+static void sine_osc_phase_incr(Oscillator* osc) {
+    osc->phase += osc->phase_dt;
+    if (osc->phase >= TWO_PI)
+        osc->phase -= TWO_PI;
+}
+
+static void saw_osc_phase_incr(Oscillator* osc) {
+    osc->phase += osc->phase_dt;
+    if (osc->phase >= 1.0f)
+        osc->phase -= 1.0f;
+}
+
+static float calc_saw_phase_delta(float freq) {
+    return freq / SAMPLE_RATE;
+}
+
+static float calc_sine_phase_delta(float freq) {
+    return (TWO_PI * freq) / SAMPLE_RATE;
+}
+
+static float sineosc(Oscillator* osc) {
+    float result = sinf(osc->phase);
+    sine_osc_phase_incr(osc);
+    return result;
+}
+
+static float sign(float v) {
+    return (v > 0.0) ? 1.f : -1.f;
+}
+
+static float squareosc(Oscillator* osc) {
+    return sign(sineosc(osc));
+}
+
+static float triangleosc(Oscillator* osc) {
+    float result = 1.f - fabsf(osc->phase - 0.5f) * 4.f;
+    saw_osc_phase_incr(osc);
+    return result;
+}
+
+static float sawosc(Oscillator* osc) {
+    float result = osc->phase * 2.f - 1.f;
+    saw_osc_phase_incr(osc);
+    return result;
+}
+
+void osc_set_freq(Oscillator* osc, float freq) {
+    osc->freq = freq;
+    osc->phase = 0;
+    switch (osc->osc)
+    {
+        case Sine:
+            osc->phase_dt = calc_sine_phase_delta(freq);
+            break;
+        case Square:
+            osc->phase_dt = calc_sine_phase_delta(freq);
+            break;
+        case Triangle:
+            osc->phase_dt = calc_saw_phase_delta(freq);
+            break;
+        case Saw:
+            osc->phase_dt = calc_saw_phase_delta(freq);
+            break;
+        default:
+            break;
+    }
+}
+
+void osc_reset(Oscillator* osc) {
+    osc->volume = 0;
+    osc->phase = 0;
+    osc->phase_dt = 0;
+}
+
+float multiosc(OscillatorGenerationParameter param) {
+    float osc_sample = 0.f;
+    for (size_t i = 0; i < param.oscillators.count; i++) {
+        Oscillator* osc = &param.oscillators.array[i];
+        assert(osc);
+        
+        switch (osc->osc) {
+            case Sine:
+                osc_sample += sineosc(osc) * osc->volume;
+                break;
+            case Triangle:
+                osc_sample += triangleosc(osc) * osc->volume;
+                break;
+            case Square:
+                osc_sample += squareosc(osc) * osc->volume;
+                break;
+            case Saw:
+                osc_sample += sawosc(osc) * osc->volume;
+                break;
+        }
+    }
+
+    return osc_sample;
+}
+
+SynthSound freq(float duration, OscillatorArray osc) {
+    size_t sample_count = (size_t)(duration * SAMPLE_RATE);
+    
+    float* output = malloc(sizeof(float) * sample_count);
+    for (size_t i = 0; i < sample_count; i++) {
+        OscillatorGenerationParameter param = {
+            .oscillators = osc
+        };
+        output[i] = multiosc(param);
+    }
+    
+    SynthSound res = {
+        .samples = output,
+        .sample_count = sample_count
+    };
+
+    return res;
+}
+
+/*
+static SynthSound get_attack_samples() {
+    float attack_time = 0.001 * ATTACK_MS;
+    size_t sample_count = (size_t)(attack_time * SAMPLE_RATE);
+    float* attack = malloc(sizeof(float) * sample_count);
+    float samples_to_rise = SAMPLE_RATE * attack_time;
+    float rising_delta = 1.0 / samples_to_rise;
+    float i = 0.0;
+
+    for (int j = 0; j < sample_count; j++) {
+        i += rising_delta;
+        attack[j] = fmin(i, 1.0);
+    }
+
+    SynthSound res = {
+        .samples = attack,
+        .sample_count = sample_count
+    };
+
+    return res;
+}
+*/

oscillator.h

@@ -0,0 +1,37 @@
+#ifndef OSCILLATOR_H
+#define OSCILLATOR_H
+
+#include "utils.h"
+#define WAVE_SHAPE_OPTIONS "Sine;Triangle;Sawtooth;Square"
+typedef enum {
+    Sine,
+    Triangle,
+    Saw,
+    Square
+} OscillatorType;
+
+typedef struct Oscillator {
+    OscillatorType osc;
+    float freq;
+    float volume;
+    float phase;
+    float phase_dt;
+} Oscillator;
+
+typedef struct OscillatorArray {
+    Oscillator* array;
+    size_t count;
+} OscillatorArray;
+
+typedef struct OscillatorGenerationParameter {
+    OscillatorArray oscillators;
+} OscillatorGenerationParameter;
+
+void osc_set_freq(Oscillator* osc, float freq);
+void osc_reset(Oscillator* osc);
+float multiosc(OscillatorGenerationParameter param);
+SynthSound freq(float duration, OscillatorArray osc);
+
+
+
+#endif

parser.c

@@ -0,0 +1,94 @@
+#include "parser.h"
+#include "string.h"
+#include "stdio.h"
+
+struct StringArray {
+    char** array;
+    size_t count;
+};
+
+static void trim(char* str) {
+    size_t len = strlen(str);
+    while (len > 0 && (str[len - 1] == '\n' || str[len - 1] == ' ')) {
+        str[--len] = '\0';
+    }
+}
+
+static struct StringArray parse_note_parts(char* input) {
+    size_t count = 0;
+    size_t i = 0;
+    while (input[i] != '\0') {
+        if (input[i] == ' ')
+            count++;
+
+        i++;
+    }
+
+    char** array = malloc(sizeof(char*) * count);
+
+    char* sep = " ";
+    char* line = strtok(input, sep);
+    i = 0;
+    while (line != NULL) {
+        array[i] = strdup(line);
+        line = strtok(NULL, sep);
+        i++;
+    }
+
+    struct StringArray result = {
+        .array = array,
+        .count = count
+    };
+
+    return result;
+}
+
+NoteArray parse_notes(char* input, size_t len) {
+    struct StringArray note_strings = parse_note_parts(input);
+    
+    NoteArray notes;
+    notes.count = note_strings.count;
+
+    char* end;
+    for (size_t i = 0; i < note_strings.count; i++) {
+        char* line = note_strings.array[i];
+        trim(line);
+        
+        char* note_name = strtok(line, "-");
+        char* note_length_str = strtok(NULL, "-");
+
+        int note_length = strtol(note_length_str, &end, 10);
+        if (*end != '\0') {
+            fprintf(stderr,
+                "Failed to parse note length: %s\n", note_length_str);
+            return notes;
+        }
+        
+        char* buf = malloc(strlen(note_name) + 1);
+        strcpy(buf, note_name);
+        
+        Note note = {
+            .length = note_length,
+            .name = buf
+        };
+
+        notes.notes[i] = note;
+    }
+
+    return notes;
+}
+
+/*
+static int test(int argc, char **argv) {
+    char* input = "A4-4 A4-2 C5-8 C5-4 ";
+    char* buf = malloc(strlen(input) + 1);
+    strcpy(buf, input);
+
+    NoteArray note_array = parse_notes(buf, strlen(buf));
+    for (size_t i = 0; i < note_array.count; i++) {
+        Note note = note_array.notes[i];
+    }
+
+    return 0;
+}
+*/

parser.h

@@ -0,0 +1,20 @@
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "stdlib.h"
+
+#define MAX_NOTES 1024
+
+typedef struct Note {
+    char* name;
+    int length;
+} Note;
+
+typedef struct NoteArray {
+    Note notes[MAX_NOTES];
+    size_t count;
+} NoteArray;
+
+NoteArray parse_notes(char* input, size_t len);
+
+#endif

ring_buffer.c

@@ -0,0 +1,99 @@
+#include "ring_buffer.h"
+#include "utils.h"
+
+RingBuffer ring_buffer_init(size_t buffer_size) {
+    RingBuffer buffer = {
+        .items = calloc(buffer_size, sizeof(float)),
+        .head = 0,
+        .tail = 0,
+        .is_full = 0,
+        .is_empty = 1,
+        .size = buffer_size
+    };
+
+    return buffer;
+}
+
+void ring_buffer_reset(RingBuffer* me) {
+    me->head = 0;
+    me->tail = 0;
+    me->is_full = 0;
+}
+
+// +
+static void advance_pointer(RingBuffer* me) {
+    if(me->is_full) {
+        me->tail++;
+		if (me->tail == me->size) { 
+			me->tail = 0;
+		}
+	}
+    me->head++;
+	if (me->head == me->size) { 
+		me->head = 0;
+	}
+    size_t is_full = me->head == me->tail ? 1 : 0;
+	me->is_full = is_full;
+}
+
+// -
+static void retreat_pointer(RingBuffer* me) {
+	me->is_full = 0;
+    me->tail++;
+	if (me->tail == me->size) { 
+		me->tail = 0;
+	}
+}
+
+void ring_buffer_write(RingBuffer* buffer, float* data, size_t count) {
+    if (buffer->is_full || buffer->head + count > buffer->size) {
+        write_log("[WARN] Trying to overfill the ring buffer: \n\tIsFull:%d\n\tHead:%zu\n\tCount:%zu\n\t", 
+            buffer->is_full,
+            buffer->head, 
+            count);
+        return;
+    }
+    buffer->is_empty = 0;
+
+    for (size_t i = 0; i < count; i++) {
+        buffer->items[buffer->head] = data[i];
+        advance_pointer(buffer);
+    }
+    //me->is_empty = is_full && (me->head == me->tail);
+}
+
+int ring_buffer_read(RingBuffer* buffer, float* output, size_t count) {
+    if (buffer->is_empty) {
+        write_log("[WARN] Trying to read empty buffer");
+        return 0;
+    }
+
+    for (size_t i = 0; i < count; i++) {
+        output[i] = buffer->items[buffer->tail];
+        retreat_pointer(buffer);
+    }
+    buffer->is_empty = !buffer->is_full && (buffer->head == buffer->tail);
+    return 1;
+}
+
+size_t ring_buffer_size(RingBuffer* buffer) {
+	size_t size = buffer->size;
+	if(!buffer->is_full) {
+		if(buffer->head >= buffer->tail) {
+			size = (buffer->head - buffer->tail);
+		}
+		else {
+			size = (buffer->size + buffer->head - buffer->tail);
+		}
+	}
+
+	return size;
+}
+
+void ring_buffer_print(RingBuffer* me) {
+    write_log("[INFO] The ring buffer: \n\tIsFull:%d\n\tIsEmpty:%d\n\tHead:%zu\n\tTail:%zu\n\t", 
+                me->is_full, 
+                me->is_empty, 
+                me->head, 
+                me->tail);
+}

ring_buffer.h

@@ -0,0 +1,22 @@
+#ifndef RING_BUFFER_H
+#define RING_BUFFER_H
+
+#include "stdlib.h"
+
+typedef struct RingBuffer {
+    float* items;
+    size_t head;
+    size_t tail;
+    int is_full;
+    int is_empty;
+    size_t size;
+} RingBuffer;
+
+RingBuffer ring_buffer_init(size_t buffer_size);
+void ring_buffer_reset(RingBuffer* me);
+void ring_buffer_write(RingBuffer* buffer, float* data, size_t count);
+int ring_buffer_read(RingBuffer* buffer, float* output, size_t count);
+size_t ring_buffer_size(RingBuffer* buffer);
+void ring_buffer_print(RingBuffer* me);
+
+#endif

settings.h

@@ -1,17 +1,19 @@
-#pragma once
+#ifndef SETTINGS_H
+#define SETTINGS_H
 
-#define SAMPLE_RATE 44100.f
+#define SAMPLE_RATE 48000.f
 #define BPM 120.f
-#define BEAT_DURATION 60.f / BPM
+#define BEAT_DURATION 60.f/BPM
 #define PITCH_STANDARD 440.f
 #define VOLUME 0.5f
 #define ATTACK_MS 100.f
-#define STREAM_BUFFER_SIZE 1024
-#define FPS 60
+#define STREAM_BUFFER_SIZE 4096
 
 #define SYNTH_PI 3.1415926535f
 #define SYNTH_VOLUME 0.5f
 
 #define WINDOW_WIDTH 640
 #define WINDOW_HEIGHT 480
-#define OSCILLATOR_PANEL_WIDTH 200
+#define OSCILLATOR_PANEL_WIDTH 200
+
+#endif

src/ADSR.cpp

@@ -1,94 +0,0 @@
-#include "ADSR.h"
-#include "Logger.h"
-#include "Settings.h"
-
-ADSR::ADSR(/* args */) {
-    m_attack_time = 1.f;
-    m_decay_time = 0.4f;
-    m_sustain_level = 0.6f;
-    m_release_time = 0.8f;
-    m_ramp = new Ramp(0, SAMPLE_RATE);
-}
-
-ADSR::~ADSR() { delete m_ramp; }
-
-bool ADSR::is_attack_elapsed() {
-    return m_state == sAttack && m_ramp->IsCompleted();
-}
-
-bool ADSR::is_decay_elapsed() {
-    return m_state == sDecay && m_ramp->IsCompleted();
-}
-
-bool ADSR::is_release_elapsed() {
-    return m_state == sRelease && m_ramp->IsCompleted();
-}
-
-void ADSR::recheck_state() {
-    switch (m_state) {
-        case sAttack:
-            if (is_attack_elapsed()) {
-                m_state = sDecay;
-                m_ramp->RampTo(m_sustain_level, m_decay_time);
-            }
-            break;
-        case sDecay:
-            if (is_decay_elapsed()) {
-                m_state = sSustain;
-            }
-            break;
-        case sRelease:
-            if (is_release_elapsed()) {
-                m_state = sOff;
-            }
-            break;
-        default:
-            break;
-    }
-}
-
-void ADSR::process_sample(float* sample) {
-    if (m_state == sOff) {
-        (*sample) = 0;
-    } else if (m_state == sAttack) {
-        (*sample) = (*sample) * m_ramp->Process();
-    } else if (m_state == sDecay) {
-        (*sample) = (*sample) * m_ramp->Process();
-    } else if (m_state == sSustain) {
-        (*sample) = (*sample) * m_sustain_level;
-    } else if (m_state == sRelease) {
-        (*sample) = (*sample) * m_ramp->Process();
-    }
-}
-
-void ADSR::Trigger() {
-    write_log("Set ADSR\n");
-    if (m_state == sOff) {
-        m_state = sAttack;
-    } else if (m_state == sRelease) {
-        m_state = sAttack;
-    };
-
-    m_ramp->RampTo(1, m_attack_time);
-}
-
-void ADSR::Release() {
-    write_log("Unset ADSR\n");
-    m_state = sRelease;
-    m_ramp->RampTo(0, m_release_time);
-}
-
-void ADSR::Process(std::vector<float>& samples) {
-    for (std::size_t i = 0; i < samples.size(); i++) {
-        recheck_state();
-        process_sample(&samples[i]);
-    }
-}
-
-void ADSR::SetParameters(float attack, float decay, float sustain,
-                         float release) {
-    m_attack_time = attack;
-    m_decay_time = decay;
-    m_sustain_level = sustain;
-    m_release_time = release;
-}

src/Application.cpp

@@ -1,120 +0,0 @@
-#include "Application.h"
-#include "Logger.h"
-#include "Settings.h"
-#include <string>
-
-Application::Application(/* args */) {
-    InitSynth();
-    InitAudio();
-}
-
-Application::~Application() {
-    StopAudioStream(m_synth_stream);
-    UnloadAudioStream(m_synth_stream);
-    CloseAudioDevice();
-    CloseWindow();
-    // todo: move to gui state class destructor (make it a class)
-    for (int i = 0; i < m_synth_gui_state.oscillators.size(); i++) {
-        delete m_synth_gui_state.oscillators[i];
-    }
-}
-
-void Application::InitAudio() {
-    m_sound_played_count = 0;
-
-    InitAudioDevice();
-    SetMasterVolume(SYNTH_VOLUME);
-    SetAudioStreamBufferSizeDefault(STREAM_BUFFER_SIZE);
-    m_synth_stream = LoadAudioStream(SAMPLE_RATE, sizeof(float) * 8, 1);
-    SetAudioStreamVolume(m_synth_stream, 0.5f);
-
-    PlayAudioStream(m_synth_stream);
-}
-
-void Application::InitSynth() {
-    std::string* nameString = new std::string(std::string(new char[3]));
-    m_current_note = new Note{.length = 1, .name = (*nameString)};
-    m_current_note->name.assign("G4");
-
-    std::vector<Oscillator*> oscillators = m_synth.GetOscillators();
-    m_synth_gui_state.oscillators.reserve(oscillators.size());
-    for (size_t i = 0; i < oscillators.size(); i++) {
-        Oscillator* osc = oscillators[i];
-        assert(osc);
-
-        OscillatorGuiState* ui =
-            new OscillatorGuiState{.freq = osc->GetFreq(),
-                                   .waveshape = osc->GetType(),
-                                   .volume = osc->GetVolume()};
-        m_synth_gui_state.oscillators.push_back(ui);
-    }
-}
-
-bool Application::DetectNotePressed(Note* note) {
-    std::size_t is_pressed = 0;
-    note->length = 8;
-    if (IsKeyDown(KEY_A)) {
-        note->name.assign("A2");
-        is_pressed = 1;
-    }
-    if (IsKeyDown(KEY_B)) {
-        note->name.assign("B2");
-        is_pressed = 1;
-    }
-    if (IsKeyDown(KEY_C)) {
-        note->name.assign("C2");
-        is_pressed = 1;
-    }
-    if (IsKeyDown(KEY_D)) {
-        note->name.assign("D2");
-        is_pressed = 1;
-    }
-    if (IsKeyDown(KEY_E)) {
-        note->name.assign("E2");
-        is_pressed = 1;
-    }
-    if (IsKeyDown(KEY_F)) {
-        note->name.assign("F2");
-        is_pressed = 1;
-    }
-    if (IsKeyDown(KEY_G)) {
-        note->name.assign("G2");
-        is_pressed = 1;
-    }
-    return is_pressed == 1;
-}
-
-bool is_note_up() {
-    return IsKeyUp(KEY_A) || IsKeyUp(KEY_B) || IsKeyUp(KEY_C) ||
-           IsKeyUp(KEY_D) || IsKeyUp(KEY_E) || IsKeyUp(KEY_F) || IsKeyUp(KEY_G);
-}
-
-void Application::UpdateOnNoteInput() {
-    if (DetectNotePressed(m_current_note)) {
-        if (!m_synth.GetIsNoteTriggered()) {
-            m_synth.Trigger((*m_current_note));
-        }
-        write_log("Note played: %s\n", m_current_note->name.c_str());
-    } else if (is_note_up() && m_synth.GetIsNoteTriggered()) {
-        m_synth.Release();
-    }
-    // will produce 0 signal if ADSR is in off state
-    m_synth.Process();
-}
-
-// Play ring-buffered audio
-void Application::PlayBufferedAudio() {
-    if (IsAudioStreamProcessed(m_synth_stream)) {
-        UpdateOnNoteInput();
-        UpdateAudioStream(m_synth_stream, m_synth.GetOutSignal().data(),
-                          STREAM_BUFFER_SIZE);
-    }
-}
-
-void Application::Run() {
-    // Main game loop
-    while (!WindowShouldClose()) {
-        PlayBufferedAudio();
-        m_renderer.Draw(m_synth, m_synth_gui_state);
-    }
-}

src/BandPassFilter.cpp

@@ -1,23 +0,0 @@
-#include "BandPassFilter.h"
-
-BandPassFilter::BandPassFilter(/* args */) {}
-
-BandPassFilter::BandPassFilter(Filter* filter) {
-    m_freq = filter->GetFreq();
-    m_q = filter->GetRes();
-    m_order = filter->GetPeakGain();
-}
-
-BandPassFilter::BandPassFilter(float freq, float res, float q) {}
-
-BandPassFilter::~BandPassFilter() {}
-
-void BandPassFilter::CalculateCoefficients() {
-    CalculateNormals();
-    m_norm = 1 / (1 + m_k / m_q + m_k * m_k);
-    m_a0 = m_k / m_q * m_norm;
-    m_a1 = 0;
-    m_a2 = -m_a0;
-    m_b1 = 2 * (m_k * m_k - 1) * m_norm;
-    m_b2 = (1 - m_k / m_q + m_k * m_k) * m_norm;
-}

src/Filter.cpp

@@ -1,36 +0,0 @@
-#include "Filter.h"
-#include "Settings.h"
-
-Filter::Filter(/* args */) {}
-
-Filter::~Filter() {}
-
-void Filter::CalculateNormals() {
-    m_v = powf(10, fabs(m_order) / 20.0);
-    m_k = tanf(M_PI * m_freq);
-}
-
-void Filter::Trigger() {}
-
-void Filter::Release() {}
-
-float Filter::Process(float in) {
-    // may move to a compile-time dictionary calculation, if needed
-    CalculateCoefficients();
-    float out = in * m_a0 + m_z1;
-    m_z1 = in * m_a1 + m_z2 - m_b1 * out;
-    m_z2 = in * m_a2 - m_b2 * out;
-    return out;
-}
-
-void Filter::Process(std::vector<float>& samples) {
-    for (std::size_t i = 0; i < samples.size(); i++) {
-        samples[i] = Process(samples[i]);
-    }
-}
-
-void Filter::SetParameters(float freq, float res, float q) {
-    m_freq = freq / SAMPLE_RATE;
-    m_q = res;
-    m_order = q;
-}

src/HighPassFilter.cpp

@@ -1,23 +0,0 @@
-#include "HighPassFilter.h"
-
-HighPassFilter::HighPassFilter(/* args */) {}
-
-HighPassFilter::HighPassFilter(Filter* filter) {
-    m_freq = filter->GetFreq();
-    m_q = filter->GetRes();
-    m_order = filter->GetPeakGain();
-}
-
-HighPassFilter::HighPassFilter(float freq, float res, float q) {}
-
-HighPassFilter::~HighPassFilter() {}
-
-void HighPassFilter::CalculateCoefficients() {
-    CalculateNormals();
-    m_norm = 1 / (1 + m_k / m_q + m_k * m_k);
-    m_a0 = 1 * m_norm;
-    m_a1 = -2 * m_a0;
-    m_a2 = m_a0;
-    m_b1 = 2 * (m_k * m_k - 1) * m_norm;
-    m_b2 = (1 - m_k / m_q + m_k * m_k) * m_norm;
-}

src/LowPassFilter.cpp

@@ -1,33 +0,0 @@
-#include "LowPassFilter.h"
-#include "Settings.h"
-
-LowPassFilter::LowPassFilter() {
-    // todo: defaults
-    m_freq = 200.f / SAMPLE_RATE;
-    m_q = 1.0f;//0.707f;
-    m_order = 0;
-}
-
-LowPassFilter::LowPassFilter(float freq, float res, float q) {
-    m_freq = freq / SAMPLE_RATE;
-    m_q = res;
-    m_order = q;
-}
-
-LowPassFilter::LowPassFilter(Filter* filter) {
-    m_freq = filter->GetFreq();
-    m_q = filter->GetRes();
-    m_order = filter->GetPeakGain();
-}
-
-LowPassFilter::~LowPassFilter() {}
-
-void LowPassFilter::CalculateCoefficients() {
-    CalculateNormals();
-    m_norm = 1 / (1 + m_k / m_q + m_k * m_k);
-    m_a0 = m_k * m_k * m_norm;
-    m_a1 = 2 * m_a0;
-    m_a2 = m_a0;
-    m_b1 = 2 * (m_k * m_k - 1) * m_norm;
-    m_b2 = (1 - m_k / m_q + m_k * m_k) * m_norm;
-}

src/Oscillator.cpp

@@ -1,92 +0,0 @@
-#include "Oscillator.h"
-#include "Settings.h"
-
-#define TWO_PI 2 * SYNTH_PI
-
-Oscillator::Oscillator(OscillatorType osc, float freq, float volume) {
-    SetType(osc);
-    m_freq = freq;
-    m_volume = volume;
-}
-
-Oscillator::~Oscillator() {}
-
-void Oscillator::Reset() {
-    m_volume = 0;
-    m_phase = 0;
-    m_phase_dt = 0;
-}
-
-void Oscillator::SetType(OscillatorType osc) {
-    m_osc = osc;
-    switch (m_osc) {
-        case Sine:
-            m_osc_function = &Oscillator::sineosc;
-            m_dt_function = &Oscillator::calc_sine_phase_delta;
-            break;
-        case Triangle:
-            m_osc_function = &Oscillator::triangleosc;
-            m_dt_function = &Oscillator::calc_saw_phase_delta;
-            break;
-        case Square:
-            m_osc_function = &Oscillator::squareosc;
-            m_dt_function = &Oscillator::calc_sine_phase_delta;
-            break;
-        case Saw:
-            m_osc_function = &Oscillator::sawosc;
-            m_dt_function = &Oscillator::calc_saw_phase_delta;
-            break;
-    }
-}
-
-void Oscillator::SetFreq(float freq) {
-    m_freq = freq;
-    m_phase = 0;
-    m_phase_dt = (this->*m_dt_function)(freq);
-}
-
-float Oscillator::Process() {
-    return (this->*m_osc_function)() * m_volume;
-}
-
-void Oscillator::sine_osc_phase_incr() {
-    m_phase += m_phase_dt;
-    if (m_phase >= TWO_PI)
-        m_phase -= TWO_PI;
-}
-
-void Oscillator::saw_osc_phase_incr() {
-    m_phase += m_phase_dt;
-    if (m_phase >= 1.0f)
-        m_phase -= 1.0f;
-}
-
-float Oscillator::calc_saw_phase_delta(float freq) {
-    return freq / SAMPLE_RATE;
-}
-
-float Oscillator::calc_sine_phase_delta(float freq) {
-    return (TWO_PI * freq) / SAMPLE_RATE;
-}
-
-float Oscillator::sineosc() {
-    float result = sinf(m_phase);
-    sine_osc_phase_incr();
-    return result;
-}
-
-float Oscillator::sign(float v) { return (v > 0.0) ? 1.f : -1.f; }
-
-float Oscillator::squareosc() { return sign(sineosc()); }
-
-float Oscillator::triangleosc() {
-    float result = 1.f - fabsf(m_phase - 0.5f) * 4.f;
-    saw_osc_phase_incr();
-    return result;
-}
-
-float Oscillator::sawosc() {
-    float result = m_phase * 2.f - 1.f;
-    saw_osc_phase_incr();
-    return result;
-}

src/Ramp.cpp

@@ -1,27 +0,0 @@
-#include "Ramp.h"
-#include "Logger.h"
-
-Ramp::Ramp(float starting_level, float sample_rate) {
-    m_level = starting_level;
-    m_sample_rate = sample_rate;
-}
-
-Ramp::~Ramp() {}
-
-void Ramp::RampTo(float val, float time) {
-    m_increment = (val - m_level) / (m_sample_rate * time);
-    m_counter = (int)(m_sample_rate * time);
-    write_log("Ramping from: %.1f to: %.1f by: %lf for: %d\n", m_level, val,
-              m_increment, m_counter);
-}
-
-float Ramp::Process() {
-    if (m_counter > 0) {
-        m_counter--;
-        m_level += m_increment;
-    }
-
-    return m_level;
-}
-
-bool Ramp::IsCompleted() { return m_counter == 0; }

src/Renderer.cpp

@@ -1,273 +0,0 @@
-#include "Renderer.h"
-#define RAYGUI_IMPLEMENTATION
-#include "Logger.h"
-#include "Settings.h"
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-but-set-variable"
-#pragma clang diagnostic ignored "-Wunused-variable"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#include "raygui.h"
-#pragma clang diagnostic pop
-
-Renderer::Renderer(/* args */) {
-    InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SeeSynth - v0.2");
-    SetTargetFPS(FPS);
-}
-
-Renderer::~Renderer() {}
-
-void Renderer::Draw(Synth& synth, SynthGuiState& synth_gui) {
-    BeginDrawing();
-    ClearBackground(RAYWHITE);
-
-    draw_ui(synth, synth_gui);
-    draw_signal(synth, synth_gui);
-
-    EndDrawing();
-}
-
-void Renderer::draw_signal(Synth& synth, SynthGuiState& synth_gui) {
-    GuiGrid((Rectangle){0, 0, WINDOW_WIDTH, WINDOW_HEIGHT}, "",
-            WINDOW_HEIGHT / 8, 2);
-    auto signal = synth.GetOutSignal();
-    Vector2* signal_points = new Vector2[signal.size()];
-    const float screen_vertical_midpoint = (WINDOW_HEIGHT / 2);
-    for (int point_idx = 0; point_idx < signal.size(); point_idx++) {
-        signal_points[point_idx].x = (float)point_idx + OSCILLATOR_PANEL_WIDTH;
-        signal_points[point_idx].y =
-            screen_vertical_midpoint + (int)(signal[point_idx] * 300);
-    }
-    DrawLineStrip(signal_points, signal.size(), RED);
-    delete[] signal_points;
-}
-
-void Renderer::draw_oscillators_shape_inputs(
-    const std::vector<Oscillator*>& oscillators,
-    const std::vector<OscillatorGuiState*>& gui_oscillators) {
-#define WAVE_SHAPE_OPTIONS "Sine;Triangle;Sawtooth;Square"
-
-    // DRAW OSCILLATOR SHAPE INPUTS
-    for (int i = 0; i < oscillators.size(); i += 1) {
-        OscillatorGuiState* ui_osc = gui_oscillators[i];
-        assert(ui_osc);
-
-        Oscillator* osc = oscillators[i];
-        assert(osc);
-
-        // Shape select
-        int shape_index = (int)(ui_osc->waveshape);
-        bool is_dropdown_click =
-            GuiDropdownBox(ui_osc->shape_dropdown_rect, WAVE_SHAPE_OPTIONS,
-                           &shape_index, ui_osc->is_dropdown_open);
-
-        if (is_dropdown_click) {
-            write_log("Dropdown clicked!\n");
-            ui_osc->is_dropdown_open = !ui_osc->is_dropdown_open;
-            ui_osc->waveshape = (OscillatorType)(shape_index);
-            // APPLY STATE TO REAL OSC
-            osc->SetType(ui_osc->waveshape);
-        }
-        if (ui_osc->is_dropdown_open)
-            break;
-    }
-}
-
-float Renderer::draw_oscillators_panels(
-    const std::vector<Oscillator*>& oscillators,
-    const std::vector<OscillatorGuiState*>& gui_oscillators,
-    const Rectangle& panel_bounds) {
-    float panel_y_offset = 0;
-    for (int i = 0; i < oscillators.size(); i++) {
-        OscillatorGuiState* ui_osc = gui_oscillators[i];
-        assert(ui_osc);
-
-        Oscillator* osc = oscillators[i];
-        assert(osc);
-
-        const bool has_shape_param = (ui_osc->waveshape == Square);
-
-        // Draw Oscillator Panel
-        const int osc_panel_width = panel_bounds.width - 20;
-        const int osc_panel_height = has_shape_param ? 130 : 100;
-        const int osc_panel_x = panel_bounds.x + 10;
-        const int osc_panel_y = panel_bounds.y + 50 + panel_y_offset;
-        panel_y_offset += osc_panel_height + 5;
-        GuiPanel((Rectangle){(float)osc_panel_x, (float)osc_panel_y,
-                             (float)osc_panel_width, (float)osc_panel_height},
-                 "");
-
-        const float slider_padding = 50.f;
-        const float el_spacing = 5.f;
-        Rectangle el_rect = {.x = (float)osc_panel_x + slider_padding + 30,
-                             .y = (float)osc_panel_y + 10,
-                             .width =
-                                 (float)osc_panel_width - (slider_padding * 2),
-                             .height = 25.f};
-
-        // Volume slider
-        float decibels = (20.f * log10f(osc->GetVolume()));
-        char amp_slider_label[32];
-        snprintf(amp_slider_label, 7, "%.1f dB", decibels);
-        decibels =
-            GuiSlider(el_rect, amp_slider_label, "", decibels, -60.0f, 0.0f);
-        ui_osc->volume = powf(10.f, decibels * (1.f / 20.f));
-        osc->SetVolume(ui_osc->volume);
-
-        el_rect.y += el_rect.height + el_spacing;
-
-        // Defer shape drop-down box.
-        ui_osc->shape_dropdown_rect = el_rect;
-        el_rect.y += el_rect.height + el_spacing;
-    }
-
-    return panel_y_offset;
-}
-
-void Renderer::draw_main_panel(const Rectangle& panel_bounds) {
-    GuiPanel(panel_bounds, "");
-}
-
-void Renderer::draw_adsr_panel(ADSR* adsr, ADSRGuiState& gui_adsr,
-                               const Rectangle& panel_bounds,
-                               float panel_y_offset) {
-    // Draw ADSR Panel
-    const int osc_panel_width = panel_bounds.width - 20;
-    const int osc_panel_height = 120;
-    const int osc_panel_x = panel_bounds.x + 10;
-    const int osc_panel_y = panel_bounds.y + 50 + panel_y_offset;
-    panel_y_offset += osc_panel_height + 5;
-    GuiPanel((Rectangle){(float)osc_panel_x, (float)osc_panel_y,
-                         (float)osc_panel_width, (float)osc_panel_height},
-             "ADSR");
-
-    const float slider_padding = 50.f;
-    const float el_spacing = 5.f;
-    Rectangle el_rect = {.x = (float)osc_panel_x + slider_padding + 30,
-                         .y = (float)osc_panel_y + 10,
-                         .width = (float)osc_panel_width - (slider_padding * 2),
-                         .height = 25.f};
-
-    // Attack slider
-    float attack = gui_adsr.attack;
-    char attack_slider_label[32];
-    snprintf(attack_slider_label, 7, "%.1f s", attack);
-    attack = GuiSlider(el_rect, attack_slider_label, "", attack, 0.0f, 2.0f);
-    gui_adsr.attack = attack;
-    el_rect.y += el_rect.height + el_spacing;
-
-    // Decay slider
-    float decay = gui_adsr.decay;
-    char decay_slider_label[32];
-    snprintf(decay_slider_label, 7, "%.1f s", decay);
-    decay = GuiSlider(el_rect, decay_slider_label, "", decay, 0.0f, 1.0f);
-    gui_adsr.decay = decay;
-    el_rect.y += el_rect.height + el_spacing;
-
-    // Sustain slider
-    float sustain = gui_adsr.sustain;
-    char sustain_slider_label[32];
-    snprintf(sustain_slider_label, 7, "%.1f u", sustain);
-    sustain = GuiSlider(el_rect, sustain_slider_label, "", sustain, 0.0f, 1.0f);
-    gui_adsr.sustain = sustain;
-    el_rect.y += el_rect.height + el_spacing;
-
-    // Release slider
-    float release = gui_adsr.release;
-    char release_slider_label[32];
-    snprintf(release_slider_label, 7, "%.1f s", release);
-    release = GuiSlider(el_rect, release_slider_label, "", release, 0.0f, 5.0f);
-    gui_adsr.release = release;
-    el_rect.y += el_rect.height + el_spacing;
-
-    // apply values to real one
-    adsr->SetParameters(gui_adsr.attack, gui_adsr.decay, gui_adsr.sustain,
-                        gui_adsr.release);
-}
-
-void Renderer::draw_second_panel(Rectangle& bounds) {
-    bounds.x += bounds.width;
-    GuiPanel(bounds, "");
-}
-
-float Renderer::DrawFilterPanel(Synth& synth, FilterGuiState& gui_filter,
-                                  const Rectangle& panel_bounds) {
-#define FILTER_TYPE_OPTIONS "LP;BP;HP"
-    Filter* filter = synth.GetFilter();
-    float panel_y_offset = 0;
-
-    // Draw Filter Panel
-    const int osc_panel_width = panel_bounds.width - 20;
-    const int osc_panel_height = 100;
-    const int osc_panel_x = panel_bounds.x + 10;
-    const int osc_panel_y = panel_bounds.y + 50;
-    panel_y_offset += osc_panel_height + 5;
-    GuiPanel((Rectangle){(float)osc_panel_x, (float)osc_panel_y,
-                         (float)osc_panel_width, (float)osc_panel_height},
-             "Filter");
-
-    const float slider_padding = 50.f;
-    const float el_spacing = 5.f;
-    Rectangle el_rect = {.x = (float)osc_panel_x + slider_padding + 30,
-                         .y = (float)osc_panel_y + 10,
-                         .width = (float)osc_panel_width - (slider_padding * 2),
-                         .height = 25.f};
-
-    // Frequency slider
-    float freq = log10f(gui_filter.freq);
-    char freq_slider_label[32];
-    snprintf(freq_slider_label, 10, "%.1f hz", powf(10.f, freq));
-    freq = GuiSlider(el_rect, freq_slider_label, "", freq, 0.f, 4.f);
-    gui_filter.freq = powf(10.f, freq);
-    el_rect.y += el_rect.height + el_spacing;
-
-    //todo: implement that when Res will be fixed
-    // Resonance slider
-    // float res = gui_filter.res;
-    // char res_slider_label[32];
-    // snprintf(res_slider_label, 7, "%.1f u", res);
-    // res = GuiSlider(el_rect, res_slider_label, "", res, 0.0f, 1.0f);
-    // gui_filter.res = res;
-    // el_rect.y += el_rect.height + el_spacing;
-
-    // Shape select
-    int shape_index = (int)(gui_filter.type);
-    bool is_dropdown_click =
-        GuiDropdownBox(el_rect, FILTER_TYPE_OPTIONS,
-                        &shape_index, gui_filter.is_dropdown_open);
-
-    if (is_dropdown_click) {
-        write_log("Dropdown clicked!\n");
-        gui_filter.is_dropdown_open = !gui_filter.is_dropdown_open;
-        gui_filter.type = (FilterType)(shape_index);
-        // APPLY STATE TO REAL SYNTH
-        synth.SetFilter(gui_filter.type);
-    }
-
-    // apply values to real one
-    // todo: thrid (order) parameter
-    // todo: why resonance changing does not work?
-    filter->SetParameters(gui_filter.freq, filter->GetRes(), filter->GetPeakGain());
-
-    return panel_y_offset;
-}
-
-void Renderer::draw_ui(Synth& synth, SynthGuiState& synth_gui) {
-    Rectangle panel_bounds = {.x = 0,
-                              .y = 0,
-                              .width = OSCILLATOR_PANEL_WIDTH,
-                              .height = WINDOW_HEIGHT};
-    draw_main_panel(panel_bounds);
-
-    std::vector<Oscillator*> oscillators = synth.GetOscillators();
-    std::vector<OscillatorGuiState*> gui_oscillators = synth_gui.oscillators;
-
-    float panel_y_offset =
-        draw_oscillators_panels(oscillators, gui_oscillators, panel_bounds);
-    draw_adsr_panel(synth.GetADSR(), synth_gui.adsr, panel_bounds,
-                    panel_y_offset);
-    draw_oscillators_shape_inputs(oscillators, gui_oscillators);
-
-    draw_second_panel(panel_bounds);
-    DrawFilterPanel(synth, synth_gui.filter, panel_bounds);
-}

src/SeeSynth.cpp

@@ -1,8 +0,0 @@
-#include "Application.h"
-
-int main() {
-    Application* app = new Application();
-    app->Run();
-
-    delete app;
-}

src/Synth.cpp

@@ -1,105 +0,0 @@
-#include "Synth.h"
-#include "KeyBoard.h"
-#include "Logger.h"
-#include "OscillatorType.h"
-#include "Settings.h"
-#include "FilterFactory.h"
-
-Synth::Synth(/* args */) {
-    m_lfo = new Oscillator(OscillatorType::Sine, 5.f, VOLUME);
-    add_oscillator();
-    add_oscillator();
-    AddEffect(new ADSR());
-    AddEffect(FilterFactory::GetDefaultFilter());
-    for (size_t i = 0; i < STREAM_BUFFER_SIZE; i++) {
-        float sample = 0.0f;
-        m_out_signal.push_back(sample);
-    }
-    zero_signal();
-}
-
-Synth::~Synth() {
-    m_oscillators.clear();
-    m_effects.clear();
-    m_out_signal.clear();
-}
-
-void Synth::zero_signal() {
-    float sample = 0.0f;
-    for (size_t i = 0; i < STREAM_BUFFER_SIZE; i++) {
-        m_out_signal[i] = sample;
-    }
-}
-
-void Synth::get_note() {
-    zero_signal();
-    Adder::SumOscillators(m_oscillators, m_out_signal);
-}
-
-void Synth::apply_effects() {
-    for (Effect* effect : m_effects) {
-        effect->Process(m_out_signal);
-    }
-}
-
-void Synth::trigger_note_on_effects() {
-    for (Effect* effect : m_effects) {
-        effect->Trigger();
-    }
-}
-
-void Synth::untrigger_note_on_effects() {
-    for (Effect* effect : m_effects) {
-        effect->Release();
-    }
-}
-
-void Synth::add_oscillator() {
-    m_oscillators.push_back(
-        new Oscillator(OscillatorType::Sine, 440.f, VOLUME));
-}
-
-void Synth::Trigger(Note input) {
-    int semitone_shift = KeyBoard::GetSemitoneShift(input.name);
-    float hz = KeyBoard::GetHzBySemitone(semitone_shift);
-
-    for (Oscillator* osc : m_oscillators) {
-        osc->SetFreq(hz);
-    }
-    is_note_triggered = true;
-    trigger_note_on_effects();
-}
-
-// todo: fix this
-void Synth::apply_filter_lfo() {
-    float dt = m_lfo->Process();
-    Filter* filter = (Filter*)m_effects[1];
-    float freq = filter->GetFreq();
-    //todo: check formula
-    //filter->SetParameters(freq + dt * 0.2f, filter->GetRes(), filter->GetPeakGain());
-}
-
-void Synth::Process() {
-    //todo: on each sample. 
-    //in order to do that, we need to move to per-sample processing
-    apply_filter_lfo();
-    get_note();
-    apply_effects();
-}
-
-void Synth::Release() {
-    zero_signal();
-    is_note_triggered = false;
-    untrigger_note_on_effects();
-}
-
-void Synth::AddEffect(Effect* fx) { m_effects.push_back(fx); }
-
-void Synth::SetFilter(FilterType type) {
-    Filter* old_filter = this->GetFilter();
-    if (!old_filter->IsSameFilterType(type)) {
-        Filter* new_filter = FilterFactory::CreateFilter(old_filter, type);
-        delete old_filter;
-        m_effects[1] = new_filter;
-    }
-}

utils.c

@@ -0,0 +1,30 @@
+#include "utils.h"
+#include "stdlib.h"
+#include "string.h"
+
+// frees the original sounds
+SynthSound concat_sounds(SynthSound* sounds, size_t count) {
+    size_t total_count = 0;
+    for (size_t i = 0; i < count; i++) {
+        total_count += sounds[i].sample_count;
+    }
+    // array to hold the result
+    float* total = malloc(total_count * sizeof(float));
+
+    size_t current_count = 0;
+    for (size_t i = 0; i < count; i++) {
+        memcpy(total + current_count,
+            sounds[i].samples,
+            sounds[i].sample_count * sizeof(float));
+        current_count += sounds[i].sample_count;
+
+        free(sounds[i].samples);
+    }
+
+    SynthSound result = {
+        .samples = total,
+        .sample_count = total_count
+    };
+
+    return result;
+}

utils.h

@@ -0,0 +1,23 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include "stdio.h"
+#include "assert.h"
+
+#define write_log(format,args...) do { \
+        printf(format, ## args); \
+    } while(0)
+
+//------------------------------------------------------------------------------------
+// General SynthSound
+//------------------------------------------------------------------------------------
+
+typedef struct SynthSound {
+    float* samples;
+    size_t sample_count;
+} SynthSound;
+
+// frees the original sounds
+SynthSound concat_sounds(SynthSound* sounds, size_t count);
+
+#endif