Files
ReMixer/include/ReMixer/IAudioDevice.hpp
2025-07-22 13:59:00 -05:00

86 lines
3.2 KiB
C++

#pragma once
#include <ReMixer/AudioFormat.hpp>
#include "ReMixer.h"
namespace ReMixer {
enum class DeviceType {
Unknown, Output, Input, Duplex
};
struct AudioDeviceInfo {
std::string id;
std::string name;
DeviceType type;
bool is_default;
std::set<AudioFormat> supported_formats;
};
class IAudioDevice;
/// Playback callback: client fills the buffer with audio data.
/// @param outputBuffer (raw bytes)
/// @param framesToRender
/// @param userData (passed at initalization)
/// @return number of frames actually rendered. If less than framesToRender, indicates end of stream or underrun.
using PlaybackCallback = std::function<size_t(void* outputBuffer, uint32_t framesToRender, void* userData)>;
/// Capture callback: client receives audio data from the device.
/// @param inputBuffer (raw bytes)
/// @param framesCaptured
/// @param userData (passed at init)
/// @return void (or could return a status)
using CaptureCallback = std::function<void(void* outputBuffer, uint32_t framesToRender, void* userData)>;
/// Device state change callback (e.g. device unplugged, format changed).
/// Arguments: device, newStatus.
using DeviceStateCallback = std::function<void(IAudioDevice& device, bool isRunning)>; // Simplified for now.
/// Represents the physical or logical audio hardware device. It's responsible for managing the connection to the
/// underlying audio API, enumerating streams, and providing device-specific properties.
/// A single application might have one IAudioDevice instance per type (e.g. one default output device, on default input device).
/// @see IStream.hpp
class IAudioDevice {
public:
Event<> Connected;
Event<> Disconnected;
virtual ~IAudioDevice() = default;
virtual bool Initialize(const AudioFormat& requestedFormat, uint32_t bufferSizeFrames) = 0;
virtual void Shutdown() = 0;
virtual bool IsInitialized() const = 0;
virtual bool Start() = 0;
virtual bool Stop() = 0;
virtual bool IsRunning() const = 0;
virtual void SetPlaybackCallback(PlaybackCallback callback, void* user_data = nullptr) = 0;
virtual void SetCaptureCallback(CaptureCallback callback, void* user_data = nullptr);
virtual AudioDeviceInfo GetInfo() const = 0;
virtual AudioFormat GetActualFormat() const = 0;
virtual uint32_t GetActualBufferSizeFrames() const = 0;
virtual double GetLatencyMilliseconds() const = 0;
template <typename T>
T* AsPlatformSpecific() { return dynamic_cast<T>(*this); }
/// @param type indicates if it's a playback or capture stream.
/// @param requested_format is the desired format for this stream.
/// @param buffer_size_frames is the desired buffer size in frames for this stream.
/// @see struct AudioFormat.
virtual IStream* CreateStream(StreamDirection type, const AudioFormat& requested_format, uint32_t buffer_size_frames) = 0;
// Future: EnumerateStreams(), GetActiveStreams(), etc.
// Future: Device event callbacks (e.g. unplugged, device changed)
};
}