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;
 
// Forward decl
struct AudioStream;

using AudioStreamRaw = SDL_AudioStream*;
 
// Forward decl
struct AudioStreamRef;
 
// 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);

  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 AudioFormat::AudioFormat(bool sign,
                                   bool bigendian,
                                   bool flt,
                                   Uint16 size)
  : m_audioFormat(
      AudioFormatRaw(SDL_DEFINE_AUDIO_FORMAT(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(AudioDeviceID resource) noexcept
    : m_resource(resource)
  {
  }

  constexpr AudioDevice(const AudioDevice& other) noexcept = delete;

  constexpr AudioDevice(AudioDevice&& other) noexcept
    : AudioDevice(other.release())
  {
  }
 
  constexpr AudioDevice(const AudioDeviceRef& other) = delete;
 
  constexpr AudioDevice(AudioDeviceRef&& other) = delete;

  AudioDevice(AudioDeviceRef devid, OptionalRef<const AudioSpec> spec);

  ~AudioDevice() { SDL_CloseAudioDevice(m_resource); }

  constexpr AudioDevice& operator=(AudioDevice&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }

  AudioDevice& operator=(const AudioDevice& other) = delete;

  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; }

  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(AudioStreamRef 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;

  constexpr AudioDeviceRef(AudioDeviceID resource) noexcept
    : AudioDevice(resource)
  {
  }

  constexpr AudioDeviceRef(const AudioDevice& resource) noexcept
    : AudioDevice(resource.get())
  {
  }

  constexpr AudioDeviceRef(AudioDevice&& resource) noexcept
    : AudioDevice(std::move(resource).release())
  {
  }

  constexpr AudioDeviceRef(const AudioDeviceRef& other) noexcept
    : AudioDevice(other.get())
  {
  }

  constexpr AudioDeviceRef(AudioDeviceRef&& other) noexcept
    : AudioDevice(other.get())
  {
  }

  ~AudioDeviceRef() { release(); }

  AudioDeviceRef& operator=(const AudioDeviceRef& other) noexcept
  {
    release();
    AudioDevice::operator=(AudioDevice(other.get()));
    return *this;
  }

  constexpr operator AudioDeviceID() const noexcept { return get(); }
};

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(nullptr)
  {
  }

  constexpr explicit AudioStream(AudioStreamRaw resource) noexcept
    : m_resource(resource)
  {
  }

  constexpr AudioStream(const AudioStream& other) noexcept = delete;

  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);

  AudioStream(AudioDeviceRef devid,
              OptionalRef<const AudioSpec> spec = std::nullopt,
              AudioStreamCallback callback = nullptr,
              void* userdata = nullptr);

  AudioStream(AudioDeviceRef 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;
  }

  AudioStream& operator=(const AudioStream& other) = delete;

  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; }

  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;

  constexpr AudioStreamRef(AudioStreamRaw resource) noexcept
    : AudioStream(resource)
  {
  }

  constexpr AudioStreamRef(const AudioStream& resource) noexcept
    : AudioStream(resource.get())
  {
  }

  constexpr AudioStreamRef(AudioStream&& resource) noexcept
    : AudioStream(std::move(resource).release())
  {
  }

  constexpr AudioStreamRef(const AudioStreamRef& other) noexcept
    : AudioStream(other.get())
  {
  }

  constexpr AudioStreamRef(AudioStreamRef&& other) noexcept
    : AudioStream(other.get())
  {
  }

  ~AudioStreamRef() { release(); }

  AudioStreamRef& operator=(const AudioStreamRef& other) noexcept
  {
    release();
    AudioStream::operator=(AudioStream(other.get()));
    return *this;
  }

  constexpr operator AudioStreamRaw() const noexcept { return get(); }
};

class AudioStreamLock
{
  AudioStreamRef m_lock;
 
public:
  AudioStreamLock(AudioStreamRef resource);

  AudioStreamLock(const AudioStreamLock& other) = delete;

  AudioStreamLock(AudioStreamLock&& other) noexcept
    : m_lock(std::move(other.m_lock))
  {
  }

  ~AudioStreamLock()
  {
    if (!m_lock) return;
    SDL_UnlockAudioStream(m_lock);
  }
 
  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 resource() const { 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(AudioDeviceRef devid)
{
  return CheckError(SDL_GetAudioDeviceName(devid));
}
 
inline const char* AudioDevice::GetName() const
{
  return SDL::GetAudioDeviceName(m_resource);
}

inline AudioSpec GetAudioDeviceFormat(AudioDeviceRef 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(AudioDeviceRef 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(AudioDeviceRef devid,
                                   OptionalRef<const AudioSpec> spec)
{
  return AudioDevice(devid, spec);
}
 
inline AudioDevice::AudioDevice(AudioDeviceRef devid,
                                OptionalRef<const AudioSpec> spec)
  : m_resource(CheckError(SDL_OpenAudioDevice(devid, spec)))
{
}

inline bool IsAudioDevicePhysical(AudioDeviceRef devid)
{
  return SDL_IsAudioDevicePhysical(devid);
}
 
inline bool AudioDevice::IsPhysical() const
{
  return SDL::IsAudioDevicePhysical(m_resource);
}

inline bool IsAudioDevicePlayback(AudioDeviceRef devid)
{
  return SDL_IsAudioDevicePlayback(devid);
}
 
inline bool AudioDevice::IsPlayback() const
{
  return SDL::IsAudioDevicePlayback(m_resource);
}

inline void PauseAudioDevice(AudioDeviceRef devid)
{
  CheckError(SDL_PauseAudioDevice(devid));
}
 
inline void AudioDevice::Pause() { SDL::PauseAudioDevice(m_resource); }

inline void ResumeAudioDevice(AudioDeviceRef devid)
{
  CheckError(SDL_ResumeAudioDevice(devid));
}
 
inline void AudioDevice::Resume() { SDL::ResumeAudioDevice(m_resource); }

inline bool AudioDevicePaused(AudioDeviceRef devid)
{
  return SDL_AudioDevicePaused(devid);
}
 
inline bool AudioDevice::Paused() const
{
  return SDL::AudioDevicePaused(m_resource);
}

inline float GetAudioDeviceGain(AudioDeviceRef devid)
{
  return SDL_GetAudioDeviceGain(devid);
}
 
inline float AudioDevice::GetGain() const
{
  return SDL::GetAudioDeviceGain(m_resource);
}

inline void SetAudioDeviceGain(AudioDeviceRef 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(AudioDeviceRef devid,
                             std::span<AudioStreamRef> streams)
{
  CheckError(SDL_BindAudioStreams(
    devid,
    reinterpret_cast<SDL_AudioStream* const*>(streams.data()),
    narrowS32(streams.size())));
}
 
inline void AudioDevice::BindAudioStreams(std::span<AudioStreamRef> streams)
{
  SDL::BindAudioStreams(m_resource, streams);
}

inline void BindAudioStream(AudioDeviceRef devid, AudioStreamRef stream)
{
  CheckError(SDL_BindAudioStream(devid, stream));
}
 
inline void AudioDevice::BindAudioStream(AudioStreamRef stream)
{
  SDL::BindAudioStream(m_resource, stream);
}

inline void UnbindAudioStreams(std::span<AudioStreamRef> streams)
{
  SDL_UnbindAudioStreams(
    reinterpret_cast<SDL_AudioStream* const*>(streams.data()),
    narrowS32(streams.size()));
}

inline void UnbindAudioStream(AudioStreamRef stream)
{
  SDL_UnbindAudioStream(stream);
}
 
inline void AudioStream::Unbind() { SDL::UnbindAudioStream(m_resource); }

inline AudioDeviceRef GetAudioStreamDevice(AudioStreamRef 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 AudioStream::AudioStream(OptionalRef<const AudioSpec> src_spec,
                                OptionalRef<const AudioSpec> dst_spec)
  : m_resource(CheckError(SDL_CreateAudioStream(src_spec, dst_spec)))
{
}
 
inline AudioStream::AudioStream(AudioDeviceRef devid,
                                OptionalRef<const AudioSpec> spec,
                                AudioStreamCallback callback,
                                void* userdata)
  : m_resource(
      CheckError(SDL_OpenAudioDeviceStream(devid, spec, callback, userdata)))
{
}
 
inline AudioStream::AudioStream(AudioDeviceRef devid,
                                OptionalRef<const AudioSpec> spec,
                                AudioStreamCB callback)
  : AudioStream(devid, spec)
{
  if (IsAudioDevicePlayback(devid)) {
    SetGetCallback(std::move(callback));
  } else {
    SetPutCallback(std::move(callback));
  }
}

inline PropertiesRef GetAudioStreamProperties(AudioStreamRef 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(AudioStreamRef 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(AudioStreamRef 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(AudioStreamRef stream)
{
  return SDL_GetAudioStreamFrequencyRatio(stream);
}
 
inline float AudioStream::GetFrequencyRatio() const
{
  return SDL::GetAudioStreamFrequencyRatio(m_resource);
}

inline void SetAudioStreamFrequencyRatio(AudioStreamRef stream, float ratio)
{
  CheckError(SDL_SetAudioStreamFrequencyRatio(stream, ratio));
}
 
inline void AudioStream::SetFrequencyRatio(float ratio)
{
  SDL::SetAudioStreamFrequencyRatio(m_resource, ratio);
}

inline float GetAudioStreamGain(AudioStreamRef stream)
{
  return SDL_GetAudioStreamGain(stream);
}
 
inline float AudioStream::GetGain() const
{
  return SDL::GetAudioStreamGain(m_resource);
}

inline void SetAudioStreamGain(AudioStreamRef stream, float gain)
{
  CheckError(SDL_SetAudioStreamGain(stream, gain));
}
 
inline void AudioStream::SetGain(float gain)
{
  SDL::SetAudioStreamGain(m_resource, gain);
}

inline OwnArray<int> GetAudioStreamInputChannelMap(AudioStreamRef 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(AudioStreamRef 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(AudioStreamRef stream,
                                          std::span<int> chmap)
{
  CheckError(SDL_SetAudioStreamInputChannelMap(
    stream, chmap.data(), narrowS32(chmap.size())));
}
 
inline void AudioStream::SetInputChannelMap(std::span<int> chmap)
{
  SDL::SetAudioStreamInputChannelMap(m_resource, chmap);
}

inline void SetAudioStreamOutputChannelMap(AudioStreamRef stream,
                                           std::span<int> chmap)
{
  CheckError(SDL_SetAudioStreamOutputChannelMap(
    stream, chmap.data(), narrowS32(chmap.size())));
}
 
inline void AudioStream::SetOutputChannelMap(std::span<int> chmap)
{
  SDL::SetAudioStreamOutputChannelMap(m_resource, chmap);
}

inline void PutAudioStreamData(AudioStreamRef stream, SourceBytes buf)
{
  CheckError(
    SDL_PutAudioStreamData(stream, buf.data(), narrowS32(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(AudioStreamRef stream,
                                     SourceBytes buf,
                                     AudioStreamDataCompleteCallback callback,
                                     void* userdata)
{
  CheckError(SDL_PutAudioStreamDataNoCopy(
    stream, buf.data(), narrowS32(buf.size_bytes()), callback, userdata));
}

inline void PutAudioStreamDataNoCopy(AudioStreamRef 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), std::move(callback));
}

inline void PutAudioStreamPlanarData(AudioStreamRef 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(AudioStreamRef stream, TargetBytes buf)
{
  return SDL_GetAudioStreamData(
    stream, buf.data(), narrowS32(buf.size_bytes()));
}
 
inline int AudioStream::GetData(TargetBytes buf)
{
  return SDL::GetAudioStreamData(m_resource, std::move(buf));
}

inline int GetAudioStreamAvailable(AudioStreamRef stream)
{
  return SDL_GetAudioStreamAvailable(stream);
}
 
inline int AudioStream::GetAvailable() const
{
  return SDL::GetAudioStreamAvailable(m_resource);
}

inline int GetAudioStreamQueued(AudioStreamRef stream)
{
  return SDL_GetAudioStreamQueued(stream);
}
 
inline int AudioStream::GetQueued() const
{
  return SDL::GetAudioStreamQueued(m_resource);
}

inline void FlushAudioStream(AudioStreamRef stream)
{
  CheckError(SDL_FlushAudioStream(stream));
}
 
inline void AudioStream::Flush() { SDL::FlushAudioStream(m_resource); }

inline void ClearAudioStream(AudioStreamRef stream)
{
  CheckError(SDL_ClearAudioStream(stream));
}
 
inline void AudioStream::Clear() { SDL::ClearAudioStream(m_resource); }

inline void PauseAudioStreamDevice(AudioStreamRef stream)
{
  CheckError(SDL_PauseAudioStreamDevice(stream));
}
 
inline void AudioStream::PauseDevice()
{
  SDL::PauseAudioStreamDevice(m_resource);
}

inline void ResumeAudioStreamDevice(AudioStreamRef stream)
{
  CheckError(SDL_ResumeAudioStreamDevice(stream));
}
 
inline void AudioStream::ResumeDevice()
{
  SDL::ResumeAudioStreamDevice(m_resource);
}

inline bool AudioStreamDevicePaused(AudioStreamRef stream)
{
  return SDL_AudioStreamDevicePaused(stream);
}
 
inline bool AudioStream::DevicePaused() const
{
  return SDL::AudioStreamDevicePaused(m_resource);
}

inline void LockAudioStream(AudioStreamRef 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(AudioStreamRef stream)
{
  CheckError(SDL_UnlockAudioStream(stream));
}
 
inline void AudioStream::Unlock(AudioStreamLock&& lock)
{
  SDL_assert_paranoid(lock.resource() == *this);
  std::move(lock).reset();
}
 
inline void AudioStreamLock::reset()
{
  if (!m_lock) return;
  UnlockAudioStream(m_lock);
  m_lock = {};
}

inline void SetAudioStreamGetCallback(AudioStreamRef stream,
                                      AudioStreamCallback callback,
                                      void* userdata)
{
  CheckError(SDL_SetAudioStreamGetCallback(stream, callback, userdata));
}

inline void SetAudioStreamGetCallback(AudioStreamRef 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(AudioStreamRef stream,
                                      AudioStreamCallback callback,
                                      void* userdata)
{
  CheckError(SDL_SetAudioStreamPutCallback(stream, callback, userdata));
}

inline void SetAudioStreamPutCallback(AudioStreamRef 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(AudioDeviceRef devid,
                                         OptionalRef<const AudioSpec> spec,
                                         AudioStreamCallback callback = nullptr,
                                         void* userdata = nullptr)
{
  return AudioStream(devid, spec, callback, userdata);
}

inline AudioStream OpenAudioDeviceStream(AudioDeviceRef 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 void SetAudioPostmixCallback(AudioDeviceRef devid,
                                    AudioPostmixCallback callback,
                                    void* userdata)
{
  CheckError(SDL_SetAudioPostmixCallback(devid, callback, userdata));
}

inline void SetAudioPostmixCallback(AudioDeviceRef 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_IO(IOStreamRef 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, narrowS32(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>(),
                                     narrowS32(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_ */