float* buffer = (float*)stream;
int samples = len / sizeof(float);

double phaseInc = TWO_PI * FREQUENCY / SAMPLE_RATE;

for (int i = 0; i < samples; ++i) {
    buffer[i] = 0.05f *(float)std::sin(phase);
    phase += phaseInc;

    if (phase >= TWO_PI)
        phase -= TWO_PI;
}

want.freq     = (int)SAMPLE_RATE;
want.format   = AUDIO_F32SYS;
want.channels = 1;
want.samples  = 512;
want.callback = audioCallback;

SDL_PauseAudioDevice(dev, 0);

1
2
3
4
SynthEngine() : active(false) {
    // Allocation: Grabbing memory from the heap
    osc = new SquareOsc(440.0, 0.2, 44100.0);
}

1
2
3
~SynthEngine() {
    delete osc; // Returning the heap memory to the system
}

1
2
3
4
5
6
if (nextOsc != nullptr) {
    Oscillator* oldOsc = engine.osc; // 1. Save the current address
    engine.osc = nullptr;           // 2. Disconnect (Thread Safety!)
    delete oldOsc;                  // 3. Free the old memory
    engine.osc = nextOsc;           // 4. Point to the new object
}

1
virtual ~Oscillator() {}

1
2
3
4
5
6
7
8
9
class Oscillator {
private:
    double frequency, amplitude, phase, sampleRate;

public:
    Oscillator(double freq, double amp, double sr);
    float getNextSample();
    void setFrequency(double freq);
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include "Oscillator.h"

Oscillator::Oscillator(double freq, double amp, double sr)
    : frequency(freq), amplitude(amp), sampleRate(sr), phase(0.0) {}

float Oscillator::getNextSample() {
    float sample = (sin(phase) > 0) ? 1.0f : -1.0f;
    phase += (2.0 * M_PI * frequency) / sampleRate;
    if (phase > 2.0 * M_PI) phase -= 2.0 * M_PI;
    return sample * (float)amplitude;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#include <SDL2/SDL.h>
#include <iostream>
#include <vector>
#include "Oscillator.h"

// Ein globaler Puffer, damit der Renderer auf die Audiodaten zugreifen kann
// Wir nutzen 400 Samples, passend zur Fensterbreite
std::vector<float> visualBuffer(400, 0.0f);

class SynthEngine {
public:
    Oscillator osc;
    bool active;

    SynthEngine() : osc(440.0, 0.3, 44100.0), active(false) {}

    static void AudioCallback(void* userdata, Uint8* stream, int len) {
        SynthEngine* engine = static_cast<SynthEngine*>(userdata);
        float* buffer = reinterpret_cast<float*>(stream);
        int length = len / sizeof(float);

        for (int i = 0; i < length; i++) {
            float sample = engine->active ? engine->osc.getNextSample() : 0.0f;
            buffer[i] = sample;

            // Wir füllen den Visualisierungs-Puffer nur mit den ersten 400 Samples
            if (i < visualBuffer.size()) {
                visualBuffer[i] = sample;
            }
        }
    }
};

int main(int argc, char* argv[]) {
    SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO);

    // Fenster und Renderer erstellen
    SDL_Window* window = SDL_CreateWindow("C++ Synth Visualizer",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 300, SDL_WINDOW_SHOWN);

    // Der Renderer ist unser "Pinsel" für das Fenster
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

    SynthEngine engine;

    SDL_AudioSpec ds;
    ds.freq = 44100;
    ds.format = AUDIO_F32SYS;
    ds.channels = 1;
    ds.samples = 2048;
    ds.callback = SynthEngine::AudioCallback;
    ds.userdata = &engine;

    SDL_OpenAudio(&ds, NULL);
    SDL_PauseAudio(0);

    bool running = true;
    SDL_Event e;

    while (running) {
        while (SDL_PollEvent(&e)) {
            if (e.type == SDL_QUIT) running = false;
        }

        const Uint8* state = SDL_GetKeyboardState(NULL);
        engine.active = state[SDL_SCANCODE_SPACE];

        // --- GRAFIK RENDERING ---

        // 1. Hintergrund löschen (Schwarz/Dunkelblau)
        SDL_SetRenderDrawColor(renderer, 10, 10, 25, 255);
        SDL_RenderClear(renderer);

        // 2. Nulllinie zeichnen (Grau)
        SDL_SetRenderDrawColor(renderer, 50, 50, 50, 255);
        SDL_RenderDrawLine(renderer, 0, 150, 400, 150);

        // 3. Wellenform zeichnen (Neongrün)
        SDL_SetRenderDrawColor(renderer, 0, 255, 100, 255);
        for (int x = 0; x < (int)visualBuffer.size() - 1; x++) {
            // Wir skalieren den Sample-Wert (-1.0 bis 1.0) auf die Fensterhöhe
            // 150 ist die Mitte des Fensters, 100 ist die Amplitude
            int y1 = 150 - (int)(visualBuffer[x] * 100);
            int y2 = 150 - (int)(visualBuffer[x+1] * 100);
            SDL_RenderDrawLine(renderer, x, y1, x + 1, y2);
        }

        // 4. Alles auf den Bildschirm bringen
        SDL_RenderPresent(renderer);

        SDL_Delay(16); // Entspricht etwa 60 FPS
    }

    SDL_CloseAudio();
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}