audio.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#include <ove/audio.h>
#include <ove/audio_device.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
 
#ifdef CONFIG_OVE_AUDIO
 
namespace ove::audio
{
 
inline struct ove_audio_device_cfg device_cfg_i2s(uint32_t sample_rate, uint32_t channels,
                          uint32_t input_device)
{
    struct ove_audio_device_cfg cfg {
    };
    cfg.transport = OVE_AUDIO_TRANSPORT_I2S;
    cfg.fmt.sample_rate = sample_rate;
    cfg.fmt.channels = channels;
    cfg.fmt.sample_fmt = OVE_AUDIO_FMT_S16;
    cfg.i2s.input_device = input_device;
    return cfg;
}
 
class Graph
{
      public:
    Graph() : g_{}, initialized_(false)
    {
    }
 
    ~Graph() noexcept
    {
        if (initialized_)
            ove_audio_graph_deinit(&g_);
    }
 
    [[nodiscard]] Result<void> init(unsigned int frames_per_period) noexcept
    {
        const int rc = ove_audio_graph_init(&g_, frames_per_period);
        if (rc == OVE_OK)
            initialized_ = true;
        return from_rc(rc);
    }
 
    template <unsigned Nodes, unsigned Frames, unsigned Channels = 1, unsigned SampleBytes = 2>
    [[nodiscard]] Result<void> create() noexcept
    {
        int rc = ove_audio_graph_init(&g_, Frames);
        if (rc != OVE_OK)
            return from_rc(rc);
        initialized_ = true;
#ifdef CONFIG_OVE_ZERO_HEAP
        alignas(4) static unsigned char storage[OVE_AUDIO_GRAPH_STORAGE_BYTES(
            Nodes, Frames, Channels, SampleBytes)];
        rc = ove_audio_graph_set_buf_storage(&g_, storage, sizeof(storage));
#endif
        return from_rc(rc);
    }
 
    [[nodiscard]] Result<int> add_node(const struct ove_audio_node_ops *ops, void *ctx,
                       const char *name, enum ove_audio_node_type type) noexcept
    {
        const int rc = ove_audio_graph_add_node(&g_, ops, ctx, name, type);
        if (rc >= 0)
            return rc;
        return std::unexpected{static_cast<Error>(rc)};
    }
 
    [[nodiscard]] Result<void> connect(unsigned int from, unsigned int to) noexcept
    {
        return from_rc(ove_audio_graph_connect(&g_, from, to));
    }
 
    [[nodiscard]] Result<void> build() noexcept
    {
        return from_rc(ove_audio_graph_build(&g_));
    }
 
    [[nodiscard]] Result<void> start() noexcept
    {
        return from_rc(ove_audio_graph_start(&g_));
    }
 
    [[nodiscard]] Result<void> stop() noexcept
    {
        return from_rc(ove_audio_graph_stop(&g_));
    }
 
    [[nodiscard]] Result<void> process() noexcept
    {
        return from_rc(ove_audio_graph_process(&g_));
    }
 
    [[nodiscard]] Result<struct ove_audio_graph_stats> get_stats() const noexcept
    {
        struct ove_audio_graph_stats stats {
        };
        const int rc = ove_audio_graph_get_stats(&g_, &stats);
        return from_rc(rc, stats);
    }
 
    [[nodiscard]] Result<int> device_source(const struct ove_audio_device_cfg *cfg,
                        const char *name) noexcept
    {
        const int rc = ove_audio_device_source(&g_, cfg, name);
        if (rc >= 0)
            return rc;
        return std::unexpected{static_cast<Error>(rc)};
    }
 
    [[nodiscard]] Result<int> device_sink(const struct ove_audio_device_cfg *cfg,
                          const char *name) noexcept
    {
        const int rc = ove_audio_device_sink(&g_, cfg, name);
        if (rc >= 0)
            return rc;
        return std::unexpected{static_cast<Error>(rc)};
    }
 
    struct ove_audio_graph *raw()
    {
        return &g_;
    }
 
    template <typename T> [[nodiscard]] Result<int> add_processor(T &node, const char *name)
    {
        static const struct ove_audio_node_ops ops = {
            /* configure */
            [](void *, const struct ove_audio_fmt *in_f,
               struct ove_audio_fmt *out_f) -> int {
                if (in_f && out_f)
                    *out_f = *in_f;
                return OVE_OK;
            },
            /* start */ nullptr,
            /* stop */ nullptr,
            /* process */
            [](void *ctx, const struct ove_audio_buf *in, struct ove_audio_buf *out)
                -> int { return static_cast<T *>(ctx)->process(in, out); },
            /* destroy */ nullptr,
        };
        const int rc =
            ove_audio_graph_add_node(&g_, &ops, &node, name, OVE_AUDIO_NODE_PROCESSOR);
        if (rc >= 0)
            return rc;
        return std::unexpected{static_cast<Error>(rc)};
    }
 
      private:
    struct ove_audio_graph g_;
    bool initialized_;
};
 
} /* namespace ove::audio */
 
#endif /* CONFIG_OVE_AUDIO */