Un solo framework per ogni applicazione musicale.

// Backend side: control loop, clock, processing threads.
MainLoop loop;
net_sockets::SteadyClock clock;
miniaudio::OsProcessingThreads threads (2);

// The engine and its device callback.
engine::Engine engine ({ clock, &threads });
miniaudio::EngineAudioCallback callback (engine);

// Sine -> Gain (-12 dB) -> device output channels 0 and 1.
engine::Graph g;
const auto sine = engine.newNodeId();
const auto gain = engine.newNodeId();
const auto out = engine.newNodeId();
g.nodes = { engine::sourceNode (sine, "Sine", std::make_shared<Sine> (440.0), 2),
            engine::processorNode (gain, "Gain",
                std::make_shared<engine::GainProcessor> (0.25f), 2, 2),
            engine::sinkNode (out, "Main Out",
                std::make_shared<engine::DeviceOutput> (0), 2) };
g.edges = { engine::audioEdge (engine.newEdgeId(), sine, gain),
            engine::audioEdge (engine.newEdgeId(), gain, out) };

if (const auto r = engine.setGraph (g); ! r.ok)
{
    for (const auto& p : r.problems)
        std::printf ("problem: %s\n", p.message.c_str());
    return 1;
}

auto devices = std::make_unique<miniaudio::MiniaudioDevices> (loop, callback);

/** A sine node: what a node processor looks like (real-time safe, no allocation). */
class Sine final : public engine::NodeProcessor
{
public:
    explicit Sine (double hz) : hz_ (hz) {}

    void prepare (const engine::NodePrepare& spec) override { rate_ = spec.sampleRate; }

    bool process (engine::ProcessContext& ctx) noexcept SHUFFLE_RT override
    {
        auto& out = ctx.audioOut[0];
        const double step = 2.0 * 3.141592653589793 * hz_ / rate_;

        for (int k = 0; k < ctx.numSamples; ++k)
        {
            // A phase from the engine's sample counter: the same at any block size.
            const double phase = step * static_cast<double> (ctx.engineSample + k);
            float value = 0.0f;
            SHUFFLE_RT_ALLOW_BEGIN ("std::sin is pure arithmetic: no allocation, lock or system call")
            value = static_cast<float> (std::sin (phase));
            SHUFFLE_RT_ALLOW_END

            for (int c = 0; c < out.numChannels; ++c)
                out.channels[c][k] = value;
        }

        return true;
    }

private:
    double hz_;
    double rate_ = 48'000.0;
};