cinderwave 0.1.0__tar.gz

cinderwave-0.1.0/.gitattributes

@@ -0,0 +1,4 @@
+* text=auto eol=lf
+*.png binary
+*.wav binary
+*.uf2 binary

cinderwave-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,67 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  host:
+    name: host build + tests + demo render
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install toolchain
+        run: sudo apt-get update && sudo apt-get install -y cmake g++
+
+      - name: Configure
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+
+      - name: Build
+        run: cmake --build build --config Release -j
+
+      - name: Run tests
+        run: ctest --test-dir build --output-on-failure
+
+      - name: Render demo pattern
+        run: ./build/cinderwave_render cinderwave_demo.wav
+
+      - name: Upload demo WAV
+        uses: actions/upload-artifact@v4
+        with:
+          name: cinderwave-demo-wav
+          path: cinderwave_demo.wav
+
+  firmware:
+    name: RP2040 firmware build (.uf2)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install ARM toolchain
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y cmake gcc-arm-none-eabi
+          libnewlib-arm-none-eabi libstdc++-arm-none-eabi-newlib
+          build-essential python3
+
+      - name: Fetch Pico SDK
+        run: |
+          git clone --depth 1 --branch 2.1.0 https://github.com/raspberrypi/pico-sdk.git "$HOME/pico-sdk"
+          cd "$HOME/pico-sdk" && git submodule update --init --depth 1
+
+      - name: Configure firmware
+        env:
+          PICO_SDK_PATH: /home/runner/pico-sdk
+        run: cmake -S firmware/rp2040 -B firmware/rp2040/build -DCMAKE_BUILD_TYPE=Release
+
+      - name: Build firmware
+        run: cmake --build firmware/rp2040/build -j
+
+      - name: Upload UF2
+        uses: actions/upload-artifact@v4
+        with:
+          name: cinderwave-firmware-uf2
+          path: firmware/rp2040/build/*.uf2

cinderwave-0.1.0/.github/workflows/pypi.yml

@@ -0,0 +1,73 @@
+name: PyPI
+
+# Builds the host renderer as a native wheel on each OS (it is a compiled C++
+# binary, so there is no pure-Python wheel) plus an sdist, then publishes to
+# PyPI via Trusted Publishing on a version tag. No API token needed.
+#
+# One-time setup on PyPI: add a Trusted Publisher for project `cinderwave` ->
+# owner `Makeph`, repo `cinderwave`, workflow `pypi.yml`, environment `pypi`.
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  wheels:
+    name: wheel (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # macos-14 -> arm64, windows -> amd64. Linux and Intel-mac binary wheels
+        # are intentionally omitted: `python -m build` on a plain ubuntu runner
+        # emits a raw `linux_x86_64` tag that PyPI rejects (needs manylinux via
+        # cibuildwheel), and the macos-13 runner queue stalls. Linux/Intel-mac
+        # users install from the sdist.
+        os: [macos-14, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build --wheel
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheel-${{ matrix.os }}
+          path: dist/*.whl
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: |
+          python -m pip install --upgrade build
+          python -m build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    name: publish to PyPI
+    needs: [wheels, sdist]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

cinderwave-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+# Build output
+build/
+out/
+cmake-build-*/
+*.o
+*.obj
+*.a
+*.lib
+*.exe
+
+# Rendered audio artifacts
+*.wav
+
+# RP2040 build products
+firmware/rp2040/build/
+*.uf2
+*.elf
+*.bin
+
+# Editor/OS cruft
+.vscode/
+.idea/
+*.swp
+.DS_Store
+Thumbs.db

cinderwave-0.1.0/CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.16)
+project(cinderwave LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+if(MSVC)
+    add_compile_options(/W4)
+else()
+    add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# ---- Platform-independent DSP core -----------------------------------------
+add_library(cinderwave_core STATIC
+    src/oscillator.cpp
+    src/envelope.cpp
+    src/filter.cpp
+    src/voice.cpp
+    src/sequencer.cpp
+    src/synth.cpp
+)
+target_include_directories(cinderwave_core PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+# ---- Host renderer: bakes a demo pattern to a .wav -------------------------
+add_executable(cinderwave_render host/render.cpp)
+target_link_libraries(cinderwave_render PRIVATE cinderwave_core)
+
+# Install rule -- used by scikit-build-core to ship the host renderer as a pip
+# console script. Only the renderer is installed (not the test binary).
+include(GNUInstallDirs)
+if(DEFINED SKBUILD_SCRIPTS_DIR)
+    install(TARGETS cinderwave_render RUNTIME DESTINATION "${SKBUILD_SCRIPTS_DIR}")
+else()
+    install(TARGETS cinderwave_render RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+endif()
+
+# ---- Tests -----------------------------------------------------------------
+enable_testing()
+add_executable(cinderwave_tests
+    tests/test_main.cpp
+    tests/test_oscillator.cpp
+    tests/test_envelope.cpp
+    tests/test_filter.cpp
+    tests/test_sequencer.cpp
+    tests/test_voice.cpp
+)
+target_include_directories(cinderwave_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/tests)
+target_link_libraries(cinderwave_tests PRIVATE cinderwave_core)
+add_test(NAME cinderwave_tests COMMAND cinderwave_tests)

cinderwave-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Makeph
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cinderwave-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: cinderwave
+Version: 0.1.0
+Summary: Host renderer for the Cinderwave acid groovebox: bakes patterns to WAV through the same zero-dependency C++17 DSP core that runs on the RP2040 hardware.
+Keywords: synthesizer,audio,dsp,acid,groovebox,rp2040,cli
+Author: Makeph
+License: MIT
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C++
+Classifier: Topic :: Multimedia :: Sound/Audio :: Sound Synthesis
+Project-URL: Homepage, https://github.com/Makeph/cinderwave
+Project-URL: Repository, https://github.com/Makeph/cinderwave
+Project-URL: Issues, https://github.com/Makeph/cinderwave/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Cinderwave
+
+**An open-hardware acid groovebox that fits on a $4 microcontroller.**
+
+Cinderwave is a monophonic synth voice and 16-step sequencer in the TB-303
+idiom — band-limited oscillators, a resonant zero-delay-feedback filter,
+per-step accent and slide — running on a Raspberry Pi Pico (RP2040). The entire
+DSP core is platform-independent C++17 with **no dynamic allocation, no
+exceptions, and no dependencies**, so the *exact same code* that drives the
+hardware also renders a `.wav` on your desktop.
+
+```
+   ┌───────────┐   ┌──────────┐   ┌──────────────┐   ┌─────────┐
+   │ 16-step   │──▶│ Oscillator│──▶│ SVF filter   │──▶│ VCA     │──▶ out
+   │ sequencer │   │ saw/sqr/  │   │ (cutoff env  │   │ (amp    │
+   │ note/gate/│   │ tri/sine  │   │  + resonance)│   │  env)   │
+   │ accent/   │   │ PolyBLEP  │   └──────▲───────┘   └────▲────┘
+   │ slide     │   └───────────┘   filter env          amp env
+   └───────────┘
+```
+
+## Why it's fun
+
+- **Band-limited oscillators** — PolyBLEP saw and square, so the high notes
+  don't alias into mush on a cheap DAC.
+- **Cytomic TPT state-variable filter** — the *good* resonant filter, stable and
+  self-oscillating across the whole cutoff range.
+- **Real acid behavior** — accent boosts amplitude *and* opens the filter;
+  slide portamentos between steps without retriggering the envelope.
+- **One codebase, two worlds** — flash it to a Pico, or `cmake && ctest` it on
+  your laptop and bake the demo pattern to audio.
+
+## Quick start (no hardware needed)
+
+```sh
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j
+ctest --test-dir build --output-on-failure     # DSP unit tests
+./build/cinderwave_render out.wav              # bake the demo acid line to WAV
+```
+
+`cinderwave_render` writes ~8 seconds of the built-in demo pattern (a driving
+130 BPM bassline with accents and slides) to a 16-bit mono WAV.
+
+## Build the hardware
+
+Full bill of materials, GPIO pin map, and two audio-output options (a budget
+PWM + RC filter, or a PCM5102A I2S DAC) live in
+**[hardware/BUILD.md](hardware/BUILD.md)**.
+
+Minimum viable Cinderwave:
+
+| Part                        | Qty | Notes                                  |
+|-----------------------------|-----|----------------------------------------|
+| Raspberry Pi Pico (RP2040)  | 1   | the whole synth                        |
+| 10 kΩ linear potentiometer  | 3   | cutoff, resonance, tempo               |
+| Tactile button              | 1   | play / stop                            |
+| 1.8 kΩ resistor + 10 nF cap | 1   | RC reconstruction filter (~16 kHz)     |
+| 10 µF cap + 3.5 mm jack      | 1   | DC-blocked line out                    |
+
+## Flash the firmware
+
+```sh
+cd firmware/rp2040
+export PICO_SDK_PATH=/path/to/pico-sdk
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j
+```
+
+Hold **BOOTSEL** while plugging in the Pico, then drop
+`build/cinderwave_firmware.uf2` onto the `RPI-RP2` drive. It boots straight into
+the demo pattern; the three pots take over cutoff, resonance, and tempo, and the
+button toggles playback.
+
+## Layout
+
+```
+include/cinderwave/   Public API — the frozen DSP contract (headers only)
+src/                  DSP core: oscillator, envelope, filter, voice, sequencer, synth
+host/                 Desktop WAV renderer (uses the identical core)
+firmware/rp2040/      Pico SDK target: PWM audio + pot/button controls
+tests/                Dependency-free unit tests (built and run in CI)
+hardware/             Build guide, BOM, wiring, pin map
+```
+
+## Continuous integration
+
+Every push builds the core, runs the unit tests, renders the demo WAV, and
+cross-compiles the RP2040 `.uf2` — both artifacts are uploaded from the run. See
+[.github/workflows/ci.yml](.github/workflows/ci.yml).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

cinderwave-0.1.0/README.md

@@ -0,0 +1,94 @@
+# Cinderwave
+
+**An open-hardware acid groovebox that fits on a $4 microcontroller.**
+
+Cinderwave is a monophonic synth voice and 16-step sequencer in the TB-303
+idiom — band-limited oscillators, a resonant zero-delay-feedback filter,
+per-step accent and slide — running on a Raspberry Pi Pico (RP2040). The entire
+DSP core is platform-independent C++17 with **no dynamic allocation, no
+exceptions, and no dependencies**, so the *exact same code* that drives the
+hardware also renders a `.wav` on your desktop.
+
+```
+   ┌───────────┐   ┌──────────┐   ┌──────────────┐   ┌─────────┐
+   │ 16-step   │──▶│ Oscillator│──▶│ SVF filter   │──▶│ VCA     │──▶ out
+   │ sequencer │   │ saw/sqr/  │   │ (cutoff env  │   │ (amp    │
+   │ note/gate/│   │ tri/sine  │   │  + resonance)│   │  env)   │
+   │ accent/   │   │ PolyBLEP  │   └──────▲───────┘   └────▲────┘
+   │ slide     │   └───────────┘   filter env          amp env
+   └───────────┘
+```
+
+## Why it's fun
+
+- **Band-limited oscillators** — PolyBLEP saw and square, so the high notes
+  don't alias into mush on a cheap DAC.
+- **Cytomic TPT state-variable filter** — the *good* resonant filter, stable and
+  self-oscillating across the whole cutoff range.
+- **Real acid behavior** — accent boosts amplitude *and* opens the filter;
+  slide portamentos between steps without retriggering the envelope.
+- **One codebase, two worlds** — flash it to a Pico, or `cmake && ctest` it on
+  your laptop and bake the demo pattern to audio.
+
+## Quick start (no hardware needed)
+
+```sh
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j
+ctest --test-dir build --output-on-failure     # DSP unit tests
+./build/cinderwave_render out.wav              # bake the demo acid line to WAV
+```
+
+`cinderwave_render` writes ~8 seconds of the built-in demo pattern (a driving
+130 BPM bassline with accents and slides) to a 16-bit mono WAV.
+
+## Build the hardware
+
+Full bill of materials, GPIO pin map, and two audio-output options (a budget
+PWM + RC filter, or a PCM5102A I2S DAC) live in
+**[hardware/BUILD.md](hardware/BUILD.md)**.
+
+Minimum viable Cinderwave:
+
+| Part                        | Qty | Notes                                  |
+|-----------------------------|-----|----------------------------------------|
+| Raspberry Pi Pico (RP2040)  | 1   | the whole synth                        |
+| 10 kΩ linear potentiometer  | 3   | cutoff, resonance, tempo               |
+| Tactile button              | 1   | play / stop                            |
+| 1.8 kΩ resistor + 10 nF cap | 1   | RC reconstruction filter (~16 kHz)     |
+| 10 µF cap + 3.5 mm jack      | 1   | DC-blocked line out                    |
+
+## Flash the firmware
+
+```sh
+cd firmware/rp2040
+export PICO_SDK_PATH=/path/to/pico-sdk
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j
+```
+
+Hold **BOOTSEL** while plugging in the Pico, then drop
+`build/cinderwave_firmware.uf2` onto the `RPI-RP2` drive. It boots straight into
+the demo pattern; the three pots take over cutoff, resonance, and tempo, and the
+button toggles playback.
+
+## Layout
+
+```
+include/cinderwave/   Public API — the frozen DSP contract (headers only)
+src/                  DSP core: oscillator, envelope, filter, voice, sequencer, synth
+host/                 Desktop WAV renderer (uses the identical core)
+firmware/rp2040/      Pico SDK target: PWM audio + pot/button controls
+tests/                Dependency-free unit tests (built and run in CI)
+hardware/             Build guide, BOM, wiring, pin map
+```
+
+## Continuous integration
+
+Every push builds the core, runs the unit tests, renders the demo WAV, and
+cross-compiles the RP2040 `.uf2` — both artifacts are uploaded from the run. See
+[.github/workflows/ci.yml](.github/workflows/ci.yml).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

cinderwave-0.1.0/firmware/rp2040/CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.13)
+
+# Pull in the Raspberry Pi Pico SDK (must be located before project()).
+include(pico_sdk_import.cmake)
+
+project(cinderwave_firmware C CXX ASM)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
+
+pico_sdk_init()
+
+add_executable(cinderwave_firmware
+    main.cpp
+    # The platform-independent DSP core, compiled straight into the firmware.
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../src/oscillator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../src/envelope.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../src/filter.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../src/voice.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../src/sequencer.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../src/synth.cpp
+)
+
+target_include_directories(cinderwave_firmware PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../include
+)
+
+target_link_libraries(cinderwave_firmware
+    pico_stdlib
+    hardware_pwm
+    hardware_adc
+    hardware_irq
+)
+
+# Enable USB serial for debug logging; disable UART.
+pico_enable_stdio_usb(cinderwave_firmware 1)
+pico_enable_stdio_uart(cinderwave_firmware 0)
+
+# Produce .uf2 / .hex / .bin / .map alongside the .elf.
+pico_add_extra_outputs(cinderwave_firmware)

cinderwave-0.1.0/host/render.cpp

@@ -0,0 +1,30 @@
+#include "cinderwave/synth.h"
+
+#include "wav.h"
+
+#include <cstddef>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+int main(int argc, char** argv) {
+    const std::string path = argc > 1 ? argv[1] : "cinderwave_demo.wav";
+    constexpr float durationSeconds = 8.0f;
+    const int sampleRate = cw::kSampleRate;
+    const int sampleCount = static_cast<int>(durationSeconds * static_cast<float>(sampleRate));
+
+    cw::Synth synth(sampleRate);
+    synth.loadDemoPattern();
+    synth.sequencer().start();
+
+    std::vector<float> samples(static_cast<std::size_t>(sampleCount));
+    synth.renderBlock(samples.data(), sampleCount);
+
+    if (!cwhost::writeWav(path, samples, sampleRate)) {
+        std::fprintf(stderr, "failed to write %s\n", path.c_str());
+        return 1;
+    }
+
+    std::printf("wrote %s (%.2f seconds)\n", path.c_str(), durationSeconds);
+    return 0;
+}

cinderwave-0.1.0/host/wav.h

@@ -0,0 +1,49 @@
+// Minimal 16-bit PCM mono WAV writer — no dependencies, little-endian hosts.
+#ifndef CINDERWAVE_HOST_WAV_H
+#define CINDERWAVE_HOST_WAV_H
+
+#include <cstdint>
+#include <cstdio>
+#include <vector>
+#include <string>
+
+namespace cwhost {
+
+// Writes `samples` (nominally [-1, 1]) as a 16-bit mono WAV. Returns true on
+// success. Values are clamped before quantization.
+inline bool writeWav(const std::string& path, const std::vector<float>& samples,
+                     int sampleRate) {
+    FILE* f = std::fopen(path.c_str(), "wb");
+    if (!f) return false;
+
+    auto u32 = [&](uint32_t v) { std::fwrite(&v, 4, 1, f); };
+    auto u16 = [&](uint16_t v) { std::fwrite(&v, 2, 1, f); };
+
+    const uint32_t dataBytes = static_cast<uint32_t>(samples.size()) * 2u;
+    std::fwrite("RIFF", 1, 4, f);
+    u32(36u + dataBytes);
+    std::fwrite("WAVE", 1, 4, f);
+    std::fwrite("fmt ", 1, 4, f);
+    u32(16u);                    // PCM chunk size
+    u16(1);                      // PCM format
+    u16(1);                      // mono
+    u32(static_cast<uint32_t>(sampleRate));
+    u32(static_cast<uint32_t>(sampleRate) * 2u); // byte rate
+    u16(2);                      // block align
+    u16(16);                     // bits per sample
+    std::fwrite("data", 1, 4, f);
+    u32(dataBytes);
+
+    for (float s : samples) {
+        if (s > 1.0f) s = 1.0f;
+        if (s < -1.0f) s = -1.0f;
+        int16_t q = static_cast<int16_t>(s * 32767.0f);
+        u16(static_cast<uint16_t>(q));
+    }
+    std::fclose(f);
+    return true;
+}
+
+} // namespace cwhost
+
+#endif // CINDERWAVE_HOST_WAV_H

cinderwave-0.1.0/include/cinderwave/config.h

@@ -0,0 +1,32 @@
+// Cinderwave — open hardware groovebox for the RP2040.
+// Platform-independent DSP core. No dynamic allocation, no exceptions,
+// no hardware headers here: everything below runs identically on a Pico
+// and on a desktop host that renders to WAV.
+#ifndef CINDERWAVE_CONFIG_H
+#define CINDERWAVE_CONFIG_H
+
+#include <cstdint>
+
+namespace cw {
+
+// Audio sample type. float on host and RP2040 (the M0+ has no FPU, but the
+// pico SDK's software float is fast enough for one voice at 32 kHz; the
+// firmware converts to 12-bit PWM / 16-bit I2S at the sink).
+using Sample = float;
+
+// Default engine sample rate. Chosen so a single PWM cycle on the RP2040
+// (125 MHz / 32000 ≈ 3906 counts) still gives ~11.9 bits of amplitude range.
+constexpr int kSampleRate = 32000;
+
+// Sequencer geometry.
+constexpr int kNumSteps = 16;   // one bar of 16th notes
+constexpr int kNumTracks = 1;   // monosynth groovebox (one voice, one lane)
+
+// Clamp helper shared across the DSP core.
+inline Sample clampf(Sample x, Sample lo, Sample hi) {
+    return x < lo ? lo : (x > hi ? hi : x);
+}
+
+} // namespace cw
+
+#endif // CINDERWAVE_CONFIG_H

cinderwave-0.1.0/include/cinderwave/envelope.h

@@ -0,0 +1,45 @@
+// Linear-attack, exponential decay/release ADSR. Gate-driven so the sequencer
+// can retrigger it per step (with accent scaling the peak).
+#ifndef CINDERWAVE_ENVELOPE_H
+#define CINDERWAVE_ENVELOPE_H
+
+#include "cinderwave/config.h"
+
+namespace cw {
+
+class Envelope {
+public:
+    enum class Stage : uint8_t { Idle, Attack, Decay, Sustain, Release };
+
+    explicit Envelope(int sampleRate = kSampleRate);
+
+    void setSampleRate(int sampleRate);
+    void setAttack(Sample seconds);
+    void setDecay(Sample seconds);
+    void setSustain(Sample level);   // [0, 1]
+    void setRelease(Sample seconds);
+
+    // Rising edge starts Attack; falling edge starts Release.
+    void gate(bool on);
+    void reset();                    // silence, Idle
+
+    Stage stage() const { return stage_; }
+    bool active() const { return stage_ != Stage::Idle; }
+
+    // Advance one sample; returns current level in [0, 1].
+    Sample process();
+
+private:
+    int    sampleRate_;
+    Stage  stage_ = Stage::Idle;
+    Sample level_ = 0.0f;
+    Sample sustain_ = 0.7f;
+    // Per-stage increments/coefficients derived from the time setters.
+    Sample attackInc_ = 1.0f;    // linear per-sample rise
+    Sample decayCoef_ = 0.0f;    // exponential coefficient toward sustain
+    Sample releaseCoef_ = 0.0f;  // exponential coefficient toward 0
+};
+
+} // namespace cw
+
+#endif // CINDERWAVE_ENVELOPE_H