audio_system.hpp

// Copyright Take Vos 2020-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "audio_device.hpp"
#include "../utility/utility.hpp"
#include "../coroutine/module.hpp"
#include "../macros.hpp"
#include <vector>
#include <memory>
#include <concepts>
 
hi_export_module(hikogui.audio.audio_system);
 
namespace hi { inline namespace v1 {

hi_export class audio_system {
public:
    using notifier_type = notifier<>;
    using callback_token = notifier_type::callback_token;
    using callback_proto = notifier_type::callback_proto;

    [[nodiscard]] static audio_system &global() noexcept;
 
    audio_system() = default;
    virtual ~audio_system() = default;
    audio_system(audio_system const&) = delete;
    audio_system(audio_system&&) = delete;
    audio_system& operator=(audio_system const&) = delete;
    audio_system& operator=(audio_system&&) = delete;

    [[nodiscard]] virtual generator<audio_device &> devices() noexcept = 0;

    callback_token subscribe(forward_of<callback_proto> auto&& func, callback_flags flags = callback_flags::synchronous) noexcept
    {
        return _notifier.subscribe(hi_forward(func), flags);
    }
 
    auto operator co_await() noexcept
    {
        return _notifier.operator co_await();
    }
 
protected:
    inline static std::unique_ptr<audio_system> _global;
 
    notifier_type _notifier;
};
 
template<typename Context>
concept audio_device_filter = std::same_as<Context, audio_device_state> or std::same_as<Context, audio_direction>;
 
[[nodiscard]] constexpr bool match_audio_device(audio_device const &device) noexcept
{
    return true;
}
 
template<audio_device_filter FirstFilter, audio_device_filter... Filters>
[[nodiscard]] inline bool match_audio_device(audio_device const &device, FirstFilter &&first_filter, Filters &&...filters) noexcept
{
    if constexpr (std::same_as<FirstFilter, audio_device_state>) {
        if (device.state() != first_filter) {
            return false;
        }
    } else if constexpr (std::same_as<FirstFilter, audio_direction>) {
        if (not to_bool(device.direction() & first_filter)) {
            return false;
        }
    } else {
        hi_static_no_default();
    }
 
    return match_audio_device(device, std::forward<Filters>(filters)...);
}

template<audio_device_filter... Filters>
[[nodiscard]] generator<audio_device &> audio_devices(Filters &&...filters) noexcept
{
    for (auto &device: audio_system::global().devices()) {
        if (match_audio_device(device, std::forward<Filters>(filters)...)) {
            co_yield device;
        }
    }
}
 
}} // namespace hi::inline v1