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

using AudioDeviceID = SDL_AudioDeviceID;

using AudioDeviceRef = ResourceRefT<AudioDeviceBase>;
 
// Forward decl
struct AudioStreamBase;
 
// Forward decl
struct AudioStream;

using AudioStreamRaw = SDL_AudioStream*;

using AudioStreamRef = ResourceRefT<AudioStreamBase>;
 
// 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)>;

struct AudioDeviceBase : ResourceBaseT<AudioDeviceID>
{
  using ResourceBaseT::ResourceBaseT;

  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 AudioDevice : AudioDeviceBase
{
  using AudioDeviceBase::AudioDeviceBase;

  constexpr explicit AudioDevice(AudioDeviceID resource) noexcept
    : AudioDeviceBase(resource)
  {
  }

  constexpr AudioDevice(AudioDevice&& other) noexcept
    : AudioDevice(other.release())
  {
  }

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

  ~AudioDevice() { SDL_CloseAudioDevice(get()); }

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

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)

struct AudioStreamBase : ResourceBaseT<AudioStreamRaw>
{
  using ResourceBaseT::ResourceBaseT;

  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 AudioStream : AudioStreamBase
{
  using AudioStreamBase::AudioStreamBase;

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

  constexpr AudioStream(AudioStream&& other) noexcept
    : AudioStream(other.release())
  {
  }

  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(get()); }

  constexpr AudioStream& operator=(AudioStream&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

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* AudioDeviceBase::GetName() const
{
  return SDL::GetAudioDeviceName(get());
}

inline AudioSpec GetAudioDeviceFormat(AudioDeviceRef devid,
                                      int* sample_frames = nullptr)
{
  AudioSpec spec;
  CheckError(SDL_GetAudioDeviceFormat(devid, &spec, sample_frames));
  return spec;
}
 
inline AudioSpec AudioDeviceBase::GetFormat(int* sample_frames) const
{
  return SDL::GetAudioDeviceFormat(get(), 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> AudioDeviceBase::GetChannelMap() const
{
  return SDL::GetAudioDeviceChannelMap(get());
}

inline AudioDevice OpenAudioDevice(AudioDeviceRef devid,
                                   OptionalRef<const AudioSpec> spec)
{
  return AudioDevice(devid, spec);
}
 
inline AudioDevice::AudioDevice(AudioDeviceRef devid,
                                OptionalRef<const AudioSpec> spec)
  : AudioDevice(CheckError(SDL_OpenAudioDevice(devid, spec)))
{
}

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

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

inline void PauseAudioDevice(AudioDeviceRef devid)
{
  CheckError(SDL_PauseAudioDevice(devid));
}
 
inline void AudioDeviceBase::Pause() { SDL::PauseAudioDevice(get()); }

inline void ResumeAudioDevice(AudioDeviceRef devid)
{
  CheckError(SDL_ResumeAudioDevice(devid));
}
 
inline void AudioDeviceBase::Resume() { SDL::ResumeAudioDevice(get()); }

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

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

inline void SetAudioDeviceGain(AudioDeviceRef devid, float gain)
{
  CheckError(SDL_SetAudioDeviceGain(devid, gain));
}
 
inline void AudioDeviceBase::SetGain(float gain)
{
  SDL::SetAudioDeviceGain(get(), gain);
}

inline void CloseAudioDevice(AudioDeviceID devid)
{
  SDL_CloseAudioDevice(devid);
}
 
inline void AudioDeviceBase::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 AudioDeviceBase::BindAudioStreams(std::span<AudioStreamRef> streams)
{
  SDL::BindAudioStreams(get(), streams);
}

inline void BindAudioStream(AudioDeviceRef devid, AudioStreamRef stream)
{
  CheckError(SDL_BindAudioStream(devid, stream));
}
 
inline void AudioDeviceBase::BindAudioStream(AudioStreamRef stream)
{
  SDL::BindAudioStream(get(), 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 AudioStreamBase::Unbind() { SDL::UnbindAudioStream(get()); }

inline AudioDeviceRef GetAudioStreamDevice(AudioStreamRef stream)
{
  return SDL_GetAudioStreamDevice(stream);
}
 
inline AudioDeviceRef AudioStreamBase::GetDevice() const
{
  return SDL::GetAudioStreamDevice(get());
}

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)
  : AudioStream(CheckError(SDL_CreateAudioStream(src_spec, dst_spec)))
{
}
 
inline AudioStream::AudioStream(AudioDeviceRef devid,
                                OptionalRef<const AudioSpec> spec,
                                AudioStreamCallback callback,
                                void* userdata)
  : AudioStream(
      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 AudioStreamBase::GetProperties() const
{
  return SDL::GetAudioStreamProperties(get());
}
 
#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 AudioStreamBase::GetFormat(AudioSpec* src_spec,
                                       AudioSpec* dst_spec) const
{
  SDL::GetAudioStreamFormat(get(), 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 AudioStreamBase::SetFormat(OptionalRef<const AudioSpec> src_spec,
                                       OptionalRef<const AudioSpec> dst_spec)
{
  SDL::SetAudioStreamFormat(get(), src_spec, dst_spec);
}

inline float GetAudioStreamFrequencyRatio(AudioStreamRef stream)
{
  return SDL_GetAudioStreamFrequencyRatio(stream);
}
 
inline float AudioStreamBase::GetFrequencyRatio() const
{
  return SDL::GetAudioStreamFrequencyRatio(get());
}

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

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

inline void SetAudioStreamGain(AudioStreamRef stream, float gain)
{
  CheckError(SDL_SetAudioStreamGain(stream, gain));
}
 
inline void AudioStreamBase::SetGain(float gain)
{
  SDL::SetAudioStreamGain(get(), 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> AudioStreamBase::GetInputChannelMap() const
{
  return SDL::GetAudioStreamInputChannelMap(get());
}

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> AudioStreamBase::GetOutputChannelMap() const
{
  return SDL::GetAudioStreamOutputChannelMap(get());
}

inline void SetAudioStreamInputChannelMap(AudioStreamRef stream,
                                          std::span<int> chmap)
{
  CheckError(SDL_SetAudioStreamInputChannelMap(
    stream, chmap.data(), narrowS32(chmap.size())));
}
 
inline void AudioStreamBase::SetInputChannelMap(std::span<int> chmap)
{
  SDL::SetAudioStreamInputChannelMap(get(), chmap);
}

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

inline void PutAudioStreamData(AudioStreamRef stream, SourceBytes buf)
{
  CheckError(
    SDL_PutAudioStreamData(stream, buf.data(), narrowS32(buf.size_bytes())));
}
 
inline void AudioStreamBase::PutData(SourceBytes buf)
{
  SDL::PutAudioStreamData(get(), 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 AudioStreamBase::PutDataNoCopy(
  SourceBytes buf,
  AudioStreamDataCompleteCallback callback,
  void* userdata)
{
  SDL::PutAudioStreamDataNoCopy(get(), std::move(buf), callback, userdata);
}
 
inline void AudioStreamBase::PutDataNoCopy(SourceBytes buf,
                                           AudioStreamDataCompleteCB callback)
{
  SDL::PutAudioStreamDataNoCopy(get(), 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 AudioStreamBase::PutPlanarData(const void* const* channel_buffers,
                                           int num_channels,
                                           int num_samples)
{
  SDL::PutAudioStreamPlanarData(
    get(), 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 AudioStreamBase::GetData(TargetBytes buf)
{
  return SDL::GetAudioStreamData(get(), std::move(buf));
}

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

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

inline void FlushAudioStream(AudioStreamRef stream)
{
  CheckError(SDL_FlushAudioStream(stream));
}
 
inline void AudioStreamBase::Flush() { SDL::FlushAudioStream(get()); }

inline void ClearAudioStream(AudioStreamRef stream)
{
  CheckError(SDL_ClearAudioStream(stream));
}
 
inline void AudioStreamBase::Clear() { SDL::ClearAudioStream(get()); }

inline void PauseAudioStreamDevice(AudioStreamRef stream)
{
  CheckError(SDL_PauseAudioStreamDevice(stream));
}
 
inline void AudioStreamBase::PauseDevice()
{
  SDL::PauseAudioStreamDevice(get());
}

inline void ResumeAudioStreamDevice(AudioStreamRef stream)
{
  CheckError(SDL_ResumeAudioStreamDevice(stream));
}
 
inline void AudioStreamBase::ResumeDevice()
{
  SDL::ResumeAudioStreamDevice(get());
}

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

inline void LockAudioStream(AudioStreamRef stream)
{
  CheckError(SDL_LockAudioStream(stream));
}
 
inline AudioStreamLock AudioStreamBase::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 AudioStreamBase::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 AudioStreamBase::SetGetCallback(AudioStreamCallback callback,
                                            void* userdata)
{
  SDL::SetAudioStreamGetCallback(get(), callback, userdata);
}
 
inline void AudioStreamBase::SetGetCallback(AudioStreamCB callback)
{
  SDL::SetAudioStreamGetCallback(get(), 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 AudioStreamBase::SetPutCallback(AudioStreamCallback callback,
                                            void* userdata)
{
  SDL::SetAudioStreamPutCallback(get(), callback, userdata);
}
 
inline void AudioStreamBase::SetPutCallback(AudioStreamCB callback)
{
  SDL::SetAudioStreamPutCallback(get(), callback);
}

inline void DestroyAudioStream(AudioStreamRaw stream)
{
  SDL_DestroyAudioStream(stream);
}
 
inline void AudioStreamBase::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 AudioDeviceBase::OpenStream(
  OptionalRef<const AudioSpec> spec,
  AudioStreamCallback callback,
  void* userdata)
{
  return AudioStream(get(), spec, callback, userdata);
}
 
inline AudioStream AudioDeviceBase::OpenStream(
  OptionalRef<const AudioSpec> spec,
  AudioStreamCB callback)
{
  return SDL::OpenAudioDeviceStream(get(), 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 AudioDeviceBase::SetPostmixCallback(AudioPostmixCallback callback,
                                                void* userdata)
{
  SDL::SetAudioPostmixCallback(get(), callback, userdata);
}
 
inline void AudioDeviceBase::SetPostmixCallback(AudioPostmixCB callback)
{
  SDL::SetAudioPostmixCallback(get(), 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_ */