SDL3pp_audio.h

#ifndef SDL3PP_AUDIO_H_
#define SDL3PP_AUDIO_H_
 
#include <SDL3/SDL_audio.h>
#include "SDL3pp_iostream.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
using AudioFormatRaw = SDL_AudioFormat;
 
// Forward decl
struct AudioFormat;
 
// Forward decl
struct AudioDevice;
 
using AudioDeviceID = SDL_AudioDeviceID;
 
// Forward decl
struct AudioDeviceRef;
 
struct AudioDeviceParam
{
  AudioDeviceID value; 
 
  constexpr AudioDeviceParam(AudioDeviceID value)
    : value(value)
  {
  }
 
  constexpr AudioDeviceParam(std::nullptr_t = nullptr)
    : value(0)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AudioDeviceParam& other) const = default;
 
  constexpr operator AudioDeviceID() const { return value; }
};
 
// Forward decl
struct AudioStream;
 
using AudioStreamRaw = SDL_AudioStream*;
 
// Forward decl
struct AudioStreamRef;
 
struct AudioStreamParam
{
  AudioStreamRaw value; 
 
  constexpr AudioStreamParam(AudioStreamRaw value)
    : value(value)
  {
  }
 
  constexpr AudioStreamParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AudioStreamParam& other) const = default;
 
  constexpr operator AudioStreamRaw() const { return value; }
};
 
// Forward decl
struct AudioStreamLock;
 
constexpr Uint32 AUDIO_MASK_BITSIZE = SDL_AUDIO_MASK_BITSIZE;
 
constexpr Uint32 AUDIO_MASK_FLOAT = SDL_AUDIO_MASK_FLOAT;
 
constexpr Uint32 AUDIO_MASK_BIG_ENDIAN = SDL_AUDIO_MASK_BIG_ENDIAN;
 
constexpr Uint32 AUDIO_MASK_SIGNED = SDL_AUDIO_MASK_SIGNED;
 
using AudioSpec = SDL_AudioSpec;
 
class AudioFormat
{
  AudioFormatRaw m_audioFormat;
 
public:
  constexpr AudioFormat(AudioFormatRaw audioFormat = {}) noexcept
    : m_audioFormat(audioFormat)
  {
  }
 
  constexpr AudioFormat(bool sign, bool bigendian, bool flt, Uint16 size)
    : m_audioFormat(
        AudioFormatRaw(SDL_DEFINE_AUDIO_FORMAT(sign, bigendian, flt, size)))
  {
  }
 
  constexpr operator AudioFormatRaw() const noexcept { return m_audioFormat; }
 
  constexpr Uint16 GetBitSize() const;
 
  constexpr Uint16 GetByteSize() const;
 
  constexpr bool IsFloat() const;
 
  constexpr bool IsBigEndian() const;
 
  constexpr bool IsLittleEndian() const;
 
  constexpr bool IsSigned() const;
 
  constexpr bool IsInt() const;
 
  constexpr bool IsUnsigned() const;
 
  const char* GetName() const;
 
  int GetSilenceValue() const;
};
 
// Unfortunate name clash with SDL_oldnames.h
#undef AUDIO_U8
#undef AUDIO_S8
#undef AUDIO_S16
#undef AUDIO_S32
#undef AUDIO_F32
 
constexpr AudioFormat AUDIO_UNKNOWN =
  SDL_AUDIO_UNKNOWN; 
 
constexpr AudioFormat AUDIO_U8 = SDL_AUDIO_U8; 
 
constexpr AudioFormat AUDIO_S8 = SDL_AUDIO_S8; 
 
constexpr AudioFormat AUDIO_S16LE = SDL_AUDIO_S16LE; 
 
constexpr AudioFormat AUDIO_S16BE =
  SDL_AUDIO_S16BE; 
 
constexpr AudioFormat AUDIO_S32LE = SDL_AUDIO_S32LE; 
 
constexpr AudioFormat AUDIO_S32BE =
  SDL_AUDIO_S32BE; 
 
constexpr AudioFormat AUDIO_F32LE =
  SDL_AUDIO_F32LE; 
 
constexpr AudioFormat AUDIO_F32BE =
  SDL_AUDIO_F32BE; 
 
constexpr AudioFormat AUDIO_S16 = SDL_AUDIO_S16; 
 
constexpr AudioFormat AUDIO_S32 = SDL_AUDIO_S32; 
 
constexpr AudioFormat AUDIO_F32 = SDL_AUDIO_F32; 
 
constexpr AudioFormat DefineAudioFormat(bool sign,
                                        bool bigendian,
                                        bool flt,
                                        Uint16 size)
{
  return AudioFormat(sign, bigendian, flt, size);
}
 
constexpr Uint16 AudioBitSize(AudioFormatRaw x) { return SDL_AUDIO_BITSIZE(x); }
 
constexpr Uint16 AudioFormat::GetBitSize() const
{
  return SDL::AudioBitSize(m_audioFormat);
}
 
constexpr Uint16 AudioByteSize(AudioFormatRaw x)
{
  return SDL_AUDIO_BYTESIZE(x);
}
 
constexpr Uint16 AudioFormat::GetByteSize() const
{
  return SDL::AudioByteSize(m_audioFormat);
}
 
constexpr bool IsAudioFloat(AudioFormatRaw x) { return SDL_AUDIO_ISFLOAT(x); }
 
constexpr bool AudioFormat::IsFloat() const
{
  return SDL::IsAudioFloat(m_audioFormat);
}
 
constexpr bool IsAudioBigENDIAN(AudioFormatRaw x)
{
  return SDL_AUDIO_ISBIGENDIAN(x);
}
 
constexpr bool AudioFormat::IsBigEndian() const
{
  return SDL::IsAudioBigENDIAN(m_audioFormat);
}
 
constexpr bool IsAudioLittleEndian(AudioFormatRaw x)
{
  return SDL_AUDIO_ISLITTLEENDIAN(x);
}
 
constexpr bool AudioFormat::IsLittleEndian() const
{
  return SDL::IsAudioLittleEndian(m_audioFormat);
}
 
constexpr bool IsAudioSigned(AudioFormatRaw x) { return SDL_AUDIO_ISSIGNED(x); }
 
constexpr bool AudioFormat::IsSigned() const
{
  return SDL::IsAudioSigned(m_audioFormat);
}
 
constexpr bool IsAudioInt(AudioFormatRaw x) { return SDL_AUDIO_ISINT(x); }
 
constexpr bool AudioFormat::IsInt() const
{
  return SDL::IsAudioInt(m_audioFormat);
}
 
constexpr bool IsAudioUnsigned(AudioFormatRaw x)
{
  return SDL_AUDIO_ISUNSIGNED(x);
}
 
constexpr bool AudioFormat::IsUnsigned() const
{
  return SDL::IsAudioUnsigned(m_audioFormat);
}
 
using AudioPostmixCallback = void(SDLCALL*)(void* userdata,
                                            const AudioSpec* spec,
                                            float* buffer,
                                            int buflen);
 
using AudioPostmixCB =
  MakeFrontCallback<void(const AudioSpec* spec, float* buffer, int buflen)>;
 
using AudioStreamCallback = void(SDLCALL*)(void* userdata,
                                           AudioStreamRaw stream,
                                           int additional_amount,
                                           int total_amount);
 
using AudioStreamCB = MakeFrontCallback<
  void(AudioStreamRaw stream, int additional_amount, int total_amount)>;
 
class AudioDevice
{
  AudioDeviceID m_resource = 0;
 
public:
  constexpr AudioDevice(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit AudioDevice(const AudioDeviceID resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr AudioDevice(const AudioDevice& other) noexcept = default;
 
public:
  constexpr AudioDevice(AudioDevice&& other) noexcept
    : AudioDevice(other.release())
  {
  }
 
  constexpr AudioDevice(const AudioDeviceRef& other) = delete;
 
  constexpr AudioDevice(AudioDeviceRef&& other) = delete;
 
  AudioDevice(AudioDeviceParam devid, OptionalRef<const AudioSpec> spec)
    : m_resource(CheckError(SDL_OpenAudioDevice(devid, spec)))
  {
  }
 
  ~AudioDevice() { SDL_CloseAudioDevice(m_resource); }
 
  constexpr AudioDevice& operator=(AudioDevice&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr AudioDevice& operator=(const AudioDevice& other) noexcept = default;
 
public:
  constexpr AudioDeviceID get() const noexcept { return m_resource; }
 
  constexpr AudioDeviceID release() noexcept
  {
    auto r = m_resource;
    m_resource = 0;
    return r;
  }
 
  constexpr auto operator<=>(const AudioDevice& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator AudioDeviceParam() const noexcept { return {m_resource}; }
 
  void Close();
 
  const char* GetName() const;
 
  AudioSpec GetFormat(int* sample_frames = nullptr) const;
 
  OwnArray<int> GetChannelMap() const;
 
  bool IsPhysical() const;
 
  bool IsPlayback() const;
 
  void Pause();
 
  void Resume();
 
  bool Paused() const;
 
  float GetGain() const;
 
  void SetGain(float gain);
 
  void BindAudioStreams(std::span<AudioStreamRef> streams);
 
  void BindAudioStream(AudioStreamParam stream);
 
  void SetPostmixCallback(AudioPostmixCallback callback, void* userdata);
 
  void SetPostmixCallback(AudioPostmixCB callback);
 
  AudioStream OpenStream(OptionalRef<const AudioSpec> spec,
                         AudioStreamCallback callback,
                         void* userdata);
 
  AudioStream OpenStream(OptionalRef<const AudioSpec> spec,
                         AudioStreamCB callback);
};
 
struct AudioDeviceRef : AudioDevice
{
  using AudioDevice::AudioDevice;
 
  AudioDeviceRef(AudioDeviceParam resource) noexcept
    : AudioDevice(resource.value)
  {
  }
 
  AudioDeviceRef(AudioDeviceID resource) noexcept
    : AudioDevice(resource)
  {
  }
 
  constexpr AudioDeviceRef(const AudioDeviceRef& other) noexcept = default;
 
  ~AudioDeviceRef() { release(); }
};
 
constexpr AudioDeviceID AUDIO_DEVICE_DEFAULT_PLAYBACK =
  SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK;
 
constexpr AudioDeviceID AUDIO_DEVICE_DEFAULT_RECORDING =
  SDL_AUDIO_DEVICE_DEFAULT_RECORDING;
 
constexpr int AudioFrameSize(const AudioSpec& x)
{
  return SDL_AUDIO_FRAMESIZE(x);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
using AudioStreamDataCompleteCallback = void(SDLCALL*)(void* userdata,
                                                       const void* buf,
                                                       int buflen);
 
using AudioStreamDataCompleteCB =
  std::function<void(const void* buf, int buflen)>;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
class AudioStream
{
  AudioStreamRaw m_resource = nullptr;
 
public:
  constexpr AudioStream(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit AudioStream(const AudioStreamRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr AudioStream(const AudioStream& other) noexcept = default;
 
public:
  constexpr AudioStream(AudioStream&& other) noexcept
    : AudioStream(other.release())
  {
  }
 
  constexpr AudioStream(const AudioStreamRef& other) = delete;
 
  constexpr AudioStream(AudioStreamRef&& other) = delete;
 
  AudioStream(OptionalRef<const AudioSpec> src_spec,
              OptionalRef<const AudioSpec> dst_spec)
    : m_resource(CheckError(SDL_CreateAudioStream(src_spec, dst_spec)))
  {
  }
 
  AudioStream(AudioDeviceParam devid,
              OptionalRef<const AudioSpec> spec = std::nullopt,
              AudioStreamCallback callback = nullptr,
              void* userdata = nullptr)
    : m_resource(
        CheckError(SDL_OpenAudioDeviceStream(devid, spec, callback, userdata)))
  {
  }
 
  AudioStream(AudioDeviceParam devid,
              OptionalRef<const AudioSpec> spec,
              AudioStreamCB callback);
 
  ~AudioStream() { SDL_DestroyAudioStream(m_resource); }
 
  constexpr AudioStream& operator=(AudioStream&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr AudioStream& operator=(const AudioStream& other) noexcept = default;
 
public:
  constexpr AudioStreamRaw get() const noexcept { return m_resource; }
 
  constexpr AudioStreamRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const AudioStream& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator AudioStreamParam() const noexcept { return {m_resource}; }
 
  void Destroy();
 
  PropertiesRef GetProperties() const;
 
  AudioSpec GetInputFormat() const
  {
    AudioSpec spec;
    GetFormat(&spec, nullptr);
    return spec;
  }
 
  AudioSpec GetOutputFormat() const
  {
    AudioSpec spec;
    GetFormat(nullptr, &spec);
    return spec;
  }
 
  void GetFormat(AudioSpec* src_spec, AudioSpec* dst_spec) const;
 
  void SetInputFormat(const AudioSpec& spec) { SetFormat(spec, std::nullopt); }
 
  void SetOutputFormat(const AudioSpec& spec) { SetFormat(std::nullopt, spec); }
 
  void SetFormat(OptionalRef<const AudioSpec> src_spec,
                 OptionalRef<const AudioSpec> dst_spec);
 
  float GetFrequencyRatio() const;
 
  void SetFrequencyRatio(float ratio);
 
  float GetGain() const;
 
  void SetGain(float gain);
 
  OwnArray<int> GetInputChannelMap() const;
 
  OwnArray<int> GetOutputChannelMap() const;
 
  void SetInputChannelMap(std::span<int> chmap);
 
  void SetOutputChannelMap(std::span<int> chmap);
 
  void PutData(SourceBytes buf);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  void PutDataNoCopy(SourceBytes buf,
                     AudioStreamDataCompleteCallback callback,
                     void* userdata);
 
  void PutDataNoCopy(SourceBytes buf, AudioStreamDataCompleteCB callback);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  int GetData(TargetBytes buf);
 
  int GetAvailable() const;
 
  int GetQueued() const;
 
  void Flush();
 
  void Clear();
 
  void PauseDevice();
 
  void ResumeDevice();
 
  bool DevicePaused() const;
 
  AudioStreamLock Lock();
 
  void Unlock(AudioStreamLock&& lock);
 
  void SetGetCallback(AudioStreamCallback callback, void* userdata);
 
  void SetGetCallback(AudioStreamCB callback);
 
  void SetPutCallback(AudioStreamCallback callback, void* userdata);
 
  void SetPutCallback(AudioStreamCB callback);
 
  void Unbind();
 
  AudioDeviceRef GetDevice() const;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  void PutPlanarData(const void* const* channel_buffers,
                     int num_channels,
                     int num_samples);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
};
 
struct AudioStreamRef : AudioStream
{
  using AudioStream::AudioStream;
 
  AudioStreamRef(AudioStreamParam resource) noexcept
    : AudioStream(resource.value)
  {
  }
 
  AudioStreamRef(AudioStreamRaw resource) noexcept
    : AudioStream(resource)
  {
  }
 
  constexpr AudioStreamRef(const AudioStreamRef& other) noexcept = default;
 
  ~AudioStreamRef() { release(); }
};
 
class AudioStreamLock
{
  AudioStreamRef m_lock;
 
public:
  AudioStreamLock(AudioStreamRef resource);
 
  AudioStreamLock(const AudioStreamLock& other) = delete;
 
  constexpr AudioStreamLock(AudioStreamLock&& other) noexcept
    : m_lock(other.m_lock)
  {
    other.m_lock = {};
  }
 
  ~AudioStreamLock() { reset(); }
 
  AudioStreamLock& operator=(const AudioStreamLock& other) = delete;
 
  AudioStreamLock& operator=(AudioStreamLock&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    return *this;
  }
 
  constexpr operator bool() const { return bool(m_lock); }
 
  void reset();
 
  AudioStreamRef get() { return m_lock; }
 
  void release() { m_lock.release(); }
};
 
inline int GetNumAudioDrivers() { return SDL_GetNumAudioDrivers(); }
 
inline const char* GetAudioDriver(int index)
{
  return SDL_GetAudioDriver(index);
}
 
inline const char* GetCurrentAudioDriver()
{
  return SDL_GetCurrentAudioDriver();
}
 
inline OwnArray<AudioDeviceRef> GetAudioPlaybackDevices()
{
  int count;
  auto data = CheckError(SDL_GetAudioPlaybackDevices(&count));
  return OwnArray<AudioDeviceRef>{reinterpret_cast<AudioDeviceRef*>(data),
                                  size_t(count)};
}
 
inline OwnArray<AudioDeviceRef> GetAudioRecordingDevices()
{
  int count;
  auto data = CheckError(SDL_GetAudioRecordingDevices(&count));
  return OwnArray<AudioDeviceRef>{reinterpret_cast<AudioDeviceRef*>(data),
                                  size_t(count)};
}
 
inline const char* GetAudioDeviceName(AudioDeviceParam devid)
{
  return CheckError(SDL_GetAudioDeviceName(devid));
}
 
inline const char* AudioDevice::GetName() const
{
  return SDL::GetAudioDeviceName(m_resource);
}
 
inline AudioSpec GetAudioDeviceFormat(AudioDeviceParam devid,
                                      int* sample_frames = nullptr)
{
  AudioSpec spec;
  CheckError(SDL_GetAudioDeviceFormat(devid, &spec, sample_frames));
  return spec;
}
 
inline AudioSpec AudioDevice::GetFormat(int* sample_frames) const
{
  return SDL::GetAudioDeviceFormat(m_resource, sample_frames);
}
 
inline OwnArray<int> GetAudioDeviceChannelMap(AudioDeviceParam devid)
{
  int count;
  auto data = SDL_GetAudioDeviceChannelMap(devid, &count);
  return OwnArray<int>{data, size_t(count)};
}
 
inline OwnArray<int> AudioDevice::GetChannelMap() const
{
  return SDL::GetAudioDeviceChannelMap(m_resource);
}
 
inline AudioDevice OpenAudioDevice(AudioDeviceParam devid,
                                   OptionalRef<const AudioSpec> spec)
{
  return AudioDevice(devid, spec);
}
 
inline bool IsAudioDevicePhysical(AudioDeviceParam devid)
{
  return SDL_IsAudioDevicePhysical(devid);
}
 
inline bool AudioDevice::IsPhysical() const
{
  return SDL::IsAudioDevicePhysical(m_resource);
}
 
inline bool IsAudioDevicePlayback(AudioDeviceParam devid)
{
  return SDL_IsAudioDevicePlayback(devid);
}
 
inline bool AudioDevice::IsPlayback() const
{
  return SDL::IsAudioDevicePlayback(m_resource);
}
 
inline void PauseAudioDevice(AudioDeviceParam devid)
{
  CheckError(SDL_PauseAudioDevice(devid));
}
 
inline void AudioDevice::Pause() { SDL::PauseAudioDevice(m_resource); }
 
inline void ResumeAudioDevice(AudioDeviceParam devid)
{
  CheckError(SDL_ResumeAudioDevice(devid));
}
 
inline void AudioDevice::Resume() { SDL::ResumeAudioDevice(m_resource); }
 
inline bool AudioDevicePaused(AudioDeviceParam devid)
{
  return SDL_AudioDevicePaused(devid);
}
 
inline bool AudioDevice::Paused() const
{
  return SDL::AudioDevicePaused(m_resource);
}
 
inline float GetAudioDeviceGain(AudioDeviceParam devid)
{
  return SDL_GetAudioDeviceGain(devid);
}
 
inline float AudioDevice::GetGain() const
{
  return SDL::GetAudioDeviceGain(m_resource);
}
 
inline void SetAudioDeviceGain(AudioDeviceParam devid, float gain)
{
  CheckError(SDL_SetAudioDeviceGain(devid, gain));
}
 
inline void AudioDevice::SetGain(float gain)
{
  SDL::SetAudioDeviceGain(m_resource, gain);
}
 
inline void CloseAudioDevice(AudioDeviceID devid)
{
  SDL_CloseAudioDevice(devid);
}
 
inline void AudioDevice::Close() { CloseAudioDevice(release()); }
 
inline void BindAudioStreams(AudioDeviceParam devid,
                             std::span<AudioStreamRef> streams)
{
  CheckError(SDL_BindAudioStreams(
    devid,
    reinterpret_cast<SDL_AudioStream* const*>(streams.data()),
    streams.size()));
}
 
inline void AudioDevice::BindAudioStreams(std::span<AudioStreamRef> streams)
{
  SDL::BindAudioStreams(m_resource, streams);
}
 
inline void BindAudioStream(AudioDeviceParam devid, AudioStreamParam stream)
{
  CheckError(SDL_BindAudioStream(devid, stream));
}
 
inline void AudioDevice::BindAudioStream(AudioStreamParam stream)
{
  SDL::BindAudioStream(m_resource, stream);
}
 
inline void UnbindAudioStreams(std::span<AudioStreamRef> streams)
{
  SDL_UnbindAudioStreams(
    reinterpret_cast<SDL_AudioStream* const*>(streams.data()), streams.size());
}
 
inline void UnbindAudioStream(AudioStreamParam stream)
{
  SDL_UnbindAudioStream(stream);
}
 
inline void AudioStream::Unbind() { SDL::UnbindAudioStream(m_resource); }
 
inline AudioDeviceRef GetAudioStreamDevice(AudioStreamParam stream)
{
  return {SDL_GetAudioStreamDevice(stream)};
}
 
inline AudioDeviceRef AudioStream::GetDevice() const
{
  return SDL::GetAudioStreamDevice(m_resource);
}
 
inline AudioStream CreateAudioStream(OptionalRef<const AudioSpec> src_spec,
                                     OptionalRef<const AudioSpec> dst_spec)
{
  return AudioStream(src_spec, dst_spec);
}
 
inline PropertiesRef GetAudioStreamProperties(AudioStreamParam stream)
{
  return {CheckError(SDL_GetAudioStreamProperties(stream))};
}
 
inline PropertiesRef AudioStream::GetProperties() const
{
  return SDL::GetAudioStreamProperties(m_resource);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
namespace prop::AudioStream {
 
constexpr auto _AUTO_CLEANUP_BOOLEAN =
  SDL_PROP_AUDIOSTREAM_AUTO_CLEANUP_BOOLEAN;
 
} // namespace prop::AudioStream
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void GetAudioStreamFormat(AudioStreamParam stream,
                                 AudioSpec* src_spec,
                                 AudioSpec* dst_spec)
{
  CheckError(SDL_GetAudioStreamFormat(stream, src_spec, dst_spec));
}
 
inline void AudioStream::GetFormat(AudioSpec* src_spec,
                                   AudioSpec* dst_spec) const
{
  SDL::GetAudioStreamFormat(m_resource, src_spec, dst_spec);
}
 
inline void SetAudioStreamFormat(AudioStreamParam stream,
                                 OptionalRef<const AudioSpec> src_spec,
                                 OptionalRef<const AudioSpec> dst_spec)
{
  CheckError(SDL_SetAudioStreamFormat(stream, src_spec, dst_spec));
}
 
inline void AudioStream::SetFormat(OptionalRef<const AudioSpec> src_spec,
                                   OptionalRef<const AudioSpec> dst_spec)
{
  SDL::SetAudioStreamFormat(m_resource, src_spec, dst_spec);
}
 
inline float GetAudioStreamFrequencyRatio(AudioStreamParam stream)
{
  return SDL_GetAudioStreamFrequencyRatio(stream);
}
 
inline float AudioStream::GetFrequencyRatio() const
{
  return SDL::GetAudioStreamFrequencyRatio(m_resource);
}
 
inline void SetAudioStreamFrequencyRatio(AudioStreamParam stream, float ratio)
{
  CheckError(SDL_SetAudioStreamFrequencyRatio(stream, ratio));
}
 
inline void AudioStream::SetFrequencyRatio(float ratio)
{
  SDL::SetAudioStreamFrequencyRatio(m_resource, ratio);
}
 
inline float GetAudioStreamGain(AudioStreamParam stream)
{
  return SDL_GetAudioStreamGain(stream);
}
 
inline float AudioStream::GetGain() const
{
  return SDL::GetAudioStreamGain(m_resource);
}
 
inline void SetAudioStreamGain(AudioStreamParam stream, float gain)
{
  CheckError(SDL_SetAudioStreamGain(stream, gain));
}
 
inline void AudioStream::SetGain(float gain)
{
  SDL::SetAudioStreamGain(m_resource, gain);
}
 
inline OwnArray<int> GetAudioStreamInputChannelMap(AudioStreamParam stream)
{
  int count;
  auto data = SDL_GetAudioStreamInputChannelMap(stream, &count);
  if (!data) return {};
  return OwnArray<int>{data, size_t(count)};
}
 
inline OwnArray<int> AudioStream::GetInputChannelMap() const
{
  return SDL::GetAudioStreamInputChannelMap(m_resource);
}
 
inline OwnArray<int> GetAudioStreamOutputChannelMap(AudioStreamParam stream)
{
  int count;
  auto data = SDL_GetAudioStreamOutputChannelMap(stream, &count);
  if (!data) return {};
  return OwnArray<int>{data, size_t(count)};
}
 
inline OwnArray<int> AudioStream::GetOutputChannelMap() const
{
  return SDL::GetAudioStreamOutputChannelMap(m_resource);
}
 
inline void SetAudioStreamInputChannelMap(AudioStreamParam stream,
                                          std::span<int> chmap)
{
  CheckError(
    SDL_SetAudioStreamInputChannelMap(stream, chmap.data(), chmap.size()));
}
 
inline void AudioStream::SetInputChannelMap(std::span<int> chmap)
{
  SDL::SetAudioStreamInputChannelMap(m_resource, chmap);
}
 
inline void SetAudioStreamOutputChannelMap(AudioStreamParam stream,
                                           std::span<int> chmap)
{
  CheckError(
    SDL_SetAudioStreamOutputChannelMap(stream, chmap.data(), chmap.size()));
}
 
inline void AudioStream::SetOutputChannelMap(std::span<int> chmap)
{
  SDL::SetAudioStreamOutputChannelMap(m_resource, chmap);
}
 
inline void PutAudioStreamData(AudioStreamParam stream, SourceBytes buf)
{
  CheckError(SDL_PutAudioStreamData(stream, buf.data(), buf.size_bytes()));
}
 
inline void AudioStream::PutData(SourceBytes buf)
{
  SDL::PutAudioStreamData(m_resource, std::move(buf));
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void PutAudioStreamDataNoCopy(AudioStreamParam stream,
                                     SourceBytes buf,
                                     AudioStreamDataCompleteCallback callback,
                                     void* userdata)
{
  CheckError(SDL_PutAudioStreamDataNoCopy(
    stream, buf.data(), buf.size_bytes(), callback, userdata));
}
 
inline void PutAudioStreamDataNoCopy(AudioStreamParam stream,
                                     SourceBytes buf,
                                     AudioStreamDataCompleteCB callback)
{
  using Wrapper = CallbackWrapper<AudioStreamDataCompleteCB>;
  PutAudioStreamDataNoCopy(stream,
                           std::move(buf),
                           &Wrapper::CallOnce,
                           Wrapper::Wrap(std::move(callback)));
}
 
inline void AudioStream::PutDataNoCopy(SourceBytes buf,
                                       AudioStreamDataCompleteCallback callback,
                                       void* userdata)
{
  SDL::PutAudioStreamDataNoCopy(m_resource, std::move(buf), callback, userdata);
}
 
inline void AudioStream::PutDataNoCopy(SourceBytes buf,
                                       AudioStreamDataCompleteCB callback)
{
  SDL::PutAudioStreamDataNoCopy(m_resource, std::move(buf), callback);
}
 
inline void PutAudioStreamPlanarData(AudioStreamParam stream,
                                     const void* const* channel_buffers,
                                     int num_channels,
                                     int num_samples)
{
  CheckError(SDL_PutAudioStreamPlanarData(
    stream, channel_buffers, num_channels, num_samples));
}
 
inline void AudioStream::PutPlanarData(const void* const* channel_buffers,
                                       int num_channels,
                                       int num_samples)
{
  SDL::PutAudioStreamPlanarData(
    m_resource, channel_buffers, num_channels, num_samples);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline int GetAudioStreamData(AudioStreamParam stream, TargetBytes buf)
{
  return SDL_GetAudioStreamData(stream, buf.data(), buf.size_bytes());
}
 
inline int AudioStream::GetData(TargetBytes buf)
{
  return SDL::GetAudioStreamData(m_resource, std::move(buf));
}
 
inline int GetAudioStreamAvailable(AudioStreamParam stream)
{
  return SDL_GetAudioStreamAvailable(stream);
}
 
inline int AudioStream::GetAvailable() const
{
  return SDL::GetAudioStreamAvailable(m_resource);
}
 
inline int GetAudioStreamQueued(AudioStreamParam stream)
{
  return SDL_GetAudioStreamQueued(stream);
}
 
inline int AudioStream::GetQueued() const
{
  return SDL::GetAudioStreamQueued(m_resource);
}
 
inline void FlushAudioStream(AudioStreamParam stream)
{
  CheckError(SDL_FlushAudioStream(stream));
}
 
inline void AudioStream::Flush() { SDL::FlushAudioStream(m_resource); }
 
inline void ClearAudioStream(AudioStreamParam stream)
{
  CheckError(SDL_ClearAudioStream(stream));
}
 
inline void AudioStream::Clear() { SDL::ClearAudioStream(m_resource); }
 
inline void PauseAudioStreamDevice(AudioStreamParam stream)
{
  CheckError(SDL_PauseAudioStreamDevice(stream));
}
 
inline void AudioStream::PauseDevice()
{
  SDL::PauseAudioStreamDevice(m_resource);
}
 
inline void ResumeAudioStreamDevice(AudioStreamParam stream)
{
  CheckError(SDL_ResumeAudioStreamDevice(stream));
}
 
inline void AudioStream::ResumeDevice()
{
  SDL::ResumeAudioStreamDevice(m_resource);
}
 
inline bool AudioStreamDevicePaused(AudioStreamParam stream)
{
  return SDL_AudioStreamDevicePaused(stream);
}
 
inline bool AudioStream::DevicePaused() const
{
  return SDL::AudioStreamDevicePaused(m_resource);
}
 
inline void LockAudioStream(AudioStreamParam stream)
{
  CheckError(SDL_LockAudioStream(stream));
}
 
inline AudioStreamLock AudioStream::Lock() { return {AudioStreamRef(*this)}; }
 
inline AudioStreamLock::AudioStreamLock(AudioStreamRef resource)
  : m_lock(std::move(resource))
{
  LockAudioStream(m_lock);
}
 
inline void UnlockAudioStream(AudioStreamParam stream)
{
  CheckError(SDL_UnlockAudioStream(stream));
}
 
inline void AudioStream::Unlock(AudioStreamLock&& lock)
{
  SDL_assert_paranoid(lock.get() == *this);
  lock.reset();
}
 
inline void AudioStreamLock::reset()
{
  if (!m_lock) return;
  UnlockAudioStream(m_lock);
  m_lock = {};
}
 
inline void SetAudioStreamGetCallback(AudioStreamParam stream,
                                      AudioStreamCallback callback,
                                      void* userdata)
{
  CheckError(SDL_SetAudioStreamGetCallback(stream, callback, userdata));
}
 
inline void SetAudioStreamGetCallback(AudioStreamParam stream,
                                      AudioStreamCB callback)
{
  SetAudioStreamGetCallback(stream, callback.wrapper, callback.data);
}
 
inline void AudioStream::SetGetCallback(AudioStreamCallback callback,
                                        void* userdata)
{
  SDL::SetAudioStreamGetCallback(m_resource, callback, userdata);
}
 
inline void AudioStream::SetGetCallback(AudioStreamCB callback)
{
  SDL::SetAudioStreamGetCallback(m_resource, callback);
}
 
inline void SetAudioStreamPutCallback(AudioStreamParam stream,
                                      AudioStreamCallback callback,
                                      void* userdata)
{
  CheckError(SDL_SetAudioStreamPutCallback(stream, callback, userdata));
}
 
inline void SetAudioStreamPutCallback(AudioStreamParam stream,
                                      AudioStreamCB callback)
{
  SetAudioStreamPutCallback(stream, callback.wrapper, callback.data);
}
 
inline void AudioStream::SetPutCallback(AudioStreamCallback callback,
                                        void* userdata)
{
  SDL::SetAudioStreamPutCallback(m_resource, callback, userdata);
}
 
inline void AudioStream::SetPutCallback(AudioStreamCB callback)
{
  SDL::SetAudioStreamPutCallback(m_resource, callback);
}
 
inline void DestroyAudioStream(AudioStreamRaw stream)
{
  SDL_DestroyAudioStream(stream);
}
 
inline void AudioStream::Destroy() { DestroyAudioStream(release()); }
 
inline AudioStream OpenAudioDeviceStream(AudioDeviceParam devid,
                                         OptionalRef<const AudioSpec> spec,
                                         AudioStreamCallback callback = nullptr,
                                         void* userdata = nullptr)
{
  return AudioStream(devid, spec, callback, userdata);
}
 
inline AudioStream OpenAudioDeviceStream(AudioDeviceParam devid,
                                         OptionalRef<const AudioSpec> spec,
                                         AudioStreamCB callback)
{
  return AudioStream(devid, spec, callback);
}
 
inline AudioStream AudioDevice::OpenStream(OptionalRef<const AudioSpec> spec,
                                           AudioStreamCallback callback,
                                           void* userdata)
{
  return AudioStream(m_resource, spec, callback, userdata);
}
 
inline AudioStream AudioDevice::OpenStream(OptionalRef<const AudioSpec> spec,
                                           AudioStreamCB callback)
{
  return AudioStream(m_resource, spec, callback);
}
 
inline AudioStream::AudioStream(AudioDeviceParam devid,
                                OptionalRef<const AudioSpec> spec,
                                AudioStreamCB callback)
  : AudioStream(devid, spec)
{
  if (IsAudioDevicePlayback(devid)) {
    SetGetCallback(std::move(callback));
  } else {
    SetPutCallback(std::move(callback));
  }
}
 
inline void SetAudioPostmixCallback(AudioDeviceParam devid,
                                    AudioPostmixCallback callback,
                                    void* userdata)
{
  CheckError(SDL_SetAudioPostmixCallback(devid, callback, userdata));
}
 
inline void SetAudioPostmixCallback(AudioDeviceParam devid,
                                    AudioPostmixCB callback)
{
  SetAudioPostmixCallback(devid, callback.wrapper, callback.data);
}
 
inline void AudioDevice::SetPostmixCallback(AudioPostmixCallback callback,
                                            void* userdata)
{
  SDL::SetAudioPostmixCallback(m_resource, callback, userdata);
}
 
inline void AudioDevice::SetPostmixCallback(AudioPostmixCB callback)
{
  SDL::SetAudioPostmixCallback(m_resource, callback);
}
 
inline OwnArray<Uint8> LoadWAV(IOStreamParam src,
                               AudioSpec* spec,
                               bool closeio = false)
{
  Uint8* buf;
  Uint32 len;
  if (!SDL_LoadWAV_IO(src, closeio, spec, &buf, &len)) return {};
  return OwnArray<Uint8>{buf, size_t(len)};
}
 
inline OwnArray<Uint8> LoadWAV(StringParam path, AudioSpec* spec)
{
  Uint8* buf;
  Uint32 len;
  if (!SDL_LoadWAV(path, spec, &buf, &len)) return {};
  return OwnArray<Uint8>{buf, size_t(len)};
}
 
inline void MixAudio(Uint8* dst,
                     SourceBytes src,
                     AudioFormat format,
                     float volume)
{
  CheckError(
    SDL_MixAudio(dst, src.data_as<Uint8>(), format, src.size_bytes(), volume));
}
 
inline void MixAudio(TargetBytes dst,
                     SourceBytes src,
                     AudioFormat format,
                     float volume)
{
  if (dst.size_bytes() < src.size_bytes()) {
    MixAudio(dst.data_as<Uint8>(),
             SourceBytes{src.data(), dst.size_bytes()},
             format,
             volume);
  } else
    MixAudio(dst.data_as<Uint8>(), src, format, volume);
}
 
inline OwnArray<Uint8> ConvertAudioSamples(const AudioSpec& src_spec,
                                           SourceBytes src_data,
                                           const AudioSpec& dst_spec)
{
  Uint8* buf;
  int len;
  CheckError(SDL_ConvertAudioSamples(&src_spec,
                                     src_data.data_as<Uint8>(),
                                     src_data.size_bytes(),
                                     &dst_spec,
                                     &buf,
                                     &len));
  return OwnArray<Uint8>{buf, size_t(len)};
}
 
inline const char* GetAudioFormatName(AudioFormatRaw format)
{
  return SDL_GetAudioFormatName(format);
}
 
inline const char* AudioFormat::GetName() const
{
  return SDL::GetAudioFormatName(m_audioFormat);
}
 
inline int GetSilenceValueForFormat(AudioFormatRaw format)
{
  return SDL_GetSilenceValueForFormat(format);
}
 
inline int AudioFormat::GetSilenceValue() const
{
  return SDL::GetSilenceValueForFormat(m_audioFormat);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_AUDIO_H_ */