audio_internal.h

#pragma once
 
#include "pixelbullet/audio/audio_backend.h"
#include "pixelbullet/audio/audio_playback_handle.h"
#include "pixelbullet/audio/audio_playback_settings.h"
#include "pixelbullet/audio/audio_spatial_settings.h"
#include "pixelbullet/audio/command_queue.h"
#include "pixelbullet/filesystem/virtual_path.h"
 
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <thread>
 
namespace pixelbullet
{
class Filesystem;
 
struct AudioPlaySoundRequest
{
    AudioPlaybackHandle handle;
    std::string resolved_path;
    AudioPlaybackSettings settings;
};
 
struct AudioState
{
    std::thread audio_thread;
    CommandQueue command_queue;
    std::unique_ptr<AudioBackend> backend;
    std::atomic<AudioPlaybackHandle::ValueType> next_handle_value{ 1 };
    bool initialized = false;
};
 
namespace audio_internal
{
using BackendFactory = std::function<std::unique_ptr<AudioBackend>()>;
 
enum class WorkerStepResult
{
    Command,
    Timeout,
    Closed,
};
 
inline constexpr auto k_worker_poll_timeout = std::chrono::milliseconds(50);
 
class ScopedBackendFactoryOverride
{
public:
    explicit ScopedBackendFactoryOverride(BackendFactory factory);
    ~ScopedBackendFactoryOverride();
 
    ScopedBackendFactoryOverride(const ScopedBackendFactoryOverride&) = delete;
    ScopedBackendFactoryOverride& operator=(const ScopedBackendFactoryOverride&) = delete;
 
private:
    BackendFactory previous_factory_;
};
 
[[nodiscard]] std::unique_ptr<AudioBackend> CreateBackend();
[[nodiscard]] bool InitializeBackend(AudioState& state);
[[nodiscard]] bool InitializeBackend(AudioState& state, BackendFactory backend_factory);
void ShutdownBackend(AudioState& state);
void CloseWorkerThread(AudioState& state);
void StartWorkerThread(AudioState& state);
 
[[nodiscard]] AudioPlaybackHandle AllocatePlaybackHandle(AudioState& state) noexcept;
[[nodiscard]] float ClampVolume(float volume) noexcept;
[[nodiscard]] AudioSpatialSettings ClampSpatialSettings(AudioSpatialSettings settings) noexcept;
[[nodiscard]] bool SubmitCommandIfInitialized(AudioState& state, const std::function<void()>& command);
[[nodiscard]] std::optional<AudioPlaySoundRequest> BuildPlaySoundRequest(Filesystem& filesystem, AudioState& state,
                                                                         const VirtualPath& file_path, AudioPlaybackSettings settings);
 
[[nodiscard]] WorkerStepResult ProcessWorkerStep(AudioState& state, std::chrono::milliseconds timeout = k_worker_poll_timeout);
void RunWorkerLoop(AudioState& state);
} // namespace audio_internal
} // namespace pixelbullet