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 AudioSpec = SDL_AudioSpec;
 
// Forward decl
struct AudioDeviceBase;
 
// Forward decl
struct AudioDeviceRef;
 
// Forward decl
struct AudioDevice;
 
// Forward decl
struct AudioStreamBase;
 
// Forward decl
struct AudioStreamRef;
 
// Forward decl
struct AudioStream;
 
using OptionalAudioStream = OptionalResource<AudioStreamRef, AudioStream>;
 
// Forward decl
struct AudioStreamLock;
 
#ifdef SDL3PP_DOC
 
#define SDL_AUDIO_MASK_BITSIZE (0xFFu)
 
#define SDL_AUDIO_MASK_FLOAT (1u << 8)
 
#define SDL_AUDIO_MASK_BIG_ENDIAN (1u << 12)
 
#define SDL_AUDIO_MASK_SIGNED (1u << 15)
 
#endif // SDL3PP_DOC
 
class AudioFormat
{
  SDL_AudioFormat m_audioFormat;
 
public:
  constexpr AudioFormat(SDL_AudioFormat audioFormat = {})
    : m_audioFormat(audioFormat)
  {
  }
 
  constexpr AudioFormat(bool sign, bool bigendian, bool flt, Uint16 size)
    : m_audioFormat(
        SDL_AudioFormat(SDL_DEFINE_AUDIO_FORMAT(sign, bigendian, flt, size)))
  {
  }
 
  constexpr bool operator==(const AudioFormat& other) const = default;
 
  constexpr bool operator==(SDL_AudioFormat audioFormat) const
  {
    return operator==(AudioFormat(audioFormat));
  }
 
  constexpr operator SDL_AudioFormat() const { return m_audioFormat; }
 
  constexpr explicit operator bool() const { return m_audioFormat != 0; }
 
  constexpr Uint16 GetBitSize() { return SDL_AUDIO_BITSIZE(m_audioFormat); }
 
  constexpr Uint16 GetByteSize() { return SDL_AUDIO_BYTESIZE(m_audioFormat); }
 
  constexpr bool IsFloat() { return SDL_AUDIO_ISFLOAT(m_audioFormat); }
 
  constexpr bool IsBigEndian() { return SDL_AUDIO_ISBIGENDIAN(m_audioFormat); }
 
  constexpr bool IsLittleEndian()
  {
    return SDL_AUDIO_ISLITTLEENDIAN(m_audioFormat);
  }
 
  constexpr bool IsSigned() { return SDL_AUDIO_ISSIGNED(m_audioFormat); }
 
  constexpr bool IsInt() { return SDL_AUDIO_ISINT(m_audioFormat); }
 
  constexpr bool IsUnsigned() { return SDL_AUDIO_ISUNSIGNED(m_audioFormat); }
 
  const char* GetName() const { return SDL_GetAudioFormatName(m_audioFormat); }
 
  int GetSilenceValue() const
  {
    return SDL_GetSilenceValueForFormat(m_audioFormat);
  }
};
 
// Unfortunate name clash with SDL_oldnames.h
#undef AUDIO_U8
#undef AUDIO_S8
#undef AUDIO_S16
#undef AUDIO_S32
#undef AUDIO_F32
 
constexpr SDL_AudioFormat AUDIO_UNKNOWN =
  SDL_AUDIO_UNKNOWN; 
 
constexpr SDL_AudioFormat AUDIO_U8 = SDL_AUDIO_U8; 
 
constexpr SDL_AudioFormat AUDIO_S8 = SDL_AUDIO_S8; 
 
constexpr SDL_AudioFormat AUDIO_S16LE =
  SDL_AUDIO_S16LE; 
 
constexpr SDL_AudioFormat AUDIO_S16BE =
  SDL_AUDIO_S16BE; 
 
constexpr SDL_AudioFormat AUDIO_S32LE =
  SDL_AUDIO_S32LE; 
 
constexpr SDL_AudioFormat AUDIO_S32BE =
  SDL_AUDIO_S32BE; 
 
constexpr SDL_AudioFormat AUDIO_F32LE =
  SDL_AUDIO_F32LE; 
 
constexpr SDL_AudioFormat AUDIO_F32BE =
  SDL_AUDIO_F32BE; 
 
constexpr SDL_AudioFormat AUDIO_S16 = SDL_AUDIO_S16; 
 
constexpr SDL_AudioFormat AUDIO_S32 = SDL_AUDIO_S32; 
 
constexpr SDL_AudioFormat AUDIO_F32 = SDL_AUDIO_F32; 
 
using AudioPostmixCallback = SDL_AudioPostmixCallback;
 
using AudioPostmixCB =
  std::function<void(const AudioSpec& spec, std::span<float> buffer)>;
 
struct AudioDeviceBase : Resource<SDL_AudioDeviceID>
{
  using Resource::Resource;
 
  AudioDeviceBase(const AudioDeviceBase& devid,
                  OptionalRef<const SDL_AudioSpec> spec)
    : Resource(CheckError(SDL_OpenAudioDevice(devid.get(), spec)))
  {
  }
 
  constexpr auto operator<=>(const AudioDeviceBase& other) const
  {
    return get() <=> other.get();
  }
 
  const char* GetName() const { return SDL_GetAudioDeviceName(get()); }
 
  AudioSpec GetFormat(int* sample_frames = nullptr) const
  {
    AudioSpec spec;
    CheckError(SDL_GetAudioDeviceFormat(get(), &spec, sample_frames));
    return spec;
  }
 
  OwnArray<int> GetChannelMap() const
  {
    int count;
    auto data = SDL_GetAudioDeviceChannelMap(get(), &count);
    return OwnArray<int>{data, size_t(count)};
  }
 
  bool IsPhysical() const { return SDL_IsAudioDevicePhysical(get()); }
 
  bool IsPlayback() const { return SDL_IsAudioDevicePlayback(get()); }
 
  void Pause() { CheckError(SDL_PauseAudioDevice(get())); }
 
  void Resume() { CheckError(SDL_ResumeAudioDevice(get())); }
 
  bool Paused() const { return SDL_AudioDevicePaused(get()); }
 
  float GetGain() const { return SDL_GetAudioDeviceGain(get()); }
 
  void SetGain(float gain) { CheckError(SDL_SetAudioDeviceGain(get(), gain)); }
 
  void BindAudioStreams(std::span<AudioStreamRef> streams);
 
  void BindAudioStream(AudioStreamBase& stream);
 
  void SetPostmixCallback(AudioPostmixCB callback);
 
  void SetPostmixCallback(AudioPostmixCallback callback, void* userdata)
  {
    CheckError(SDL_SetAudioPostmixCallback(get(), callback, userdata));
  }
};
 
struct AudioDeviceRef : AudioDeviceBase
{
  using AudioDeviceBase::AudioDeviceBase;
 
  constexpr AudioDeviceRef(const AudioDeviceRef& other)
    : AudioDeviceBase(other.get())
  {
  }
 
  constexpr AudioDeviceRef(AudioDeviceRef&& other)
    : AudioDeviceBase(other.release())
  {
  }
 
  constexpr ~AudioDeviceRef() = default;
 
  AudioDeviceRef& operator=(AudioDeviceRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_AudioDeviceID newResource = {})
  {
    KeyValueWrapper<AudioDeviceRef, AudioPostmixCB>::release(*this);
    SDL_CloseAudioDevice(release(newResource));
  }
};
 
struct AudioDevice : AudioDeviceRef
{
  using AudioDeviceRef::AudioDeviceRef;
 
  constexpr explicit AudioDevice(SDL_AudioDeviceID resource = {})
    : AudioDeviceRef(resource)
  {
  }
 
  constexpr AudioDevice(const AudioDevice& other) = delete;
 
  constexpr AudioDevice(AudioDevice&& other) = default;
 
  ~AudioDevice() { reset(); }
 
  AudioDevice& operator=(AudioDevice other)
  {
    reset(other.release());
    return *this;
  }
};
 
constexpr AudioDeviceRef AUDIO_DEVICE_DEFAULT_PLAYBACK =
  SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK;
 
constexpr AudioDeviceRef AUDIO_DEVICE_DEFAULT_RECORDING =
  SDL_AUDIO_DEVICE_DEFAULT_RECORDING;
 
constexpr int AudioFrameSize(const AudioSpec& x)
{
  return SDL_AUDIO_FRAMESIZE(x);
}
 
using AudioStreamCallback = SDL_AudioStreamCallback;
 
using AudioStreamCB = std::function<
  void(AudioStreamRef stream, int additional_amount, int total_amount)>;
 
struct AudioStreamBase : Resource<SDL_AudioStream*>
{
  using Resource::Resource;
 
  AudioStreamBase(OptionalRef<const AudioSpec> src_spec,
                  OptionalRef<const AudioSpec> dst_spec)
    : Resource(CheckError(SDL_CreateAudioStream(src_spec, dst_spec)))
  {
  }
 
  AudioStreamBase(const AudioDeviceBase& devid,
                  OptionalRef<const AudioSpec> spec = std::nullopt,
                  AudioStreamCallback callback = nullptr,
                  void* userdata = nullptr)
    : Resource(CheckError(
        SDL_OpenAudioDeviceStream(devid.get(), spec, callback, userdata)))
  {
  }
 
  AudioStreamBase(const AudioDeviceBase& devid,
                  OptionalRef<const AudioSpec> spec,
                  AudioStreamCB callback)
    : AudioStreamBase(devid, std::move(spec))
  {
    if (devid.IsPlayback()) {
      SetGetCallback(std::move(callback));
    } else {
      SetPutCallback(std::move(callback));
    }
  }
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetAudioStreamProperties(get()));
  }
 
  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
  {
    CheckError(SDL_GetAudioStreamFormat(get(), src_spec, dst_spec));
  }
 
  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)
  {
    CheckError(SDL_SetAudioStreamFormat(get(), src_spec, dst_spec));
  }
 
  float GetFrequencyRatio() const
  {
    return SDL_GetAudioStreamFrequencyRatio(get());
  }
 
  void SetFrequencyRatio(float ratio)
  {
    CheckError(SDL_SetAudioStreamFrequencyRatio(get(), ratio));
  }
 
  float GetGain() const { return SDL_GetAudioStreamGain(get()); }
 
  void SetGain(float gain) { CheckError(SDL_SetAudioStreamGain(get(), gain)); }
 
  OwnArray<int> GetInputChannelMap() const
  {
    int count;
    auto data = SDL_GetAudioStreamInputChannelMap(get(), &count);
    if (!data) return {};
    return OwnArray<int>{data, size_t(count)};
  }
 
  OwnArray<int> GetOutputChannelMap() const
  {
    int count;
    auto data = SDL_GetAudioStreamOutputChannelMap(get(), &count);
    if (!data) return {};
    return OwnArray<int>{data, size_t(count)};
  }
 
  void SetInputChannelMap(std::span<int> chmap)
  {
    SDL_assert_paranoid(chmap.size() < MAX_SINT32);
    CheckError(
      SDL_SetAudioStreamInputChannelMap(get(), chmap.data(), chmap.size()));
  }
 
  void SetOutputChannelMap(std::span<int> chmap)
  {
    SDL_assert_paranoid(chmap.size() < MAX_SINT32);
    CheckError(
      SDL_SetAudioStreamOutputChannelMap(get(), chmap.data(), chmap.size()));
  }
 
  void PutData(SourceBytes buf)
  {
    SDL_assert_paranoid(buf.size_bytes < MAX_SINT32);
    CheckError(SDL_PutAudioStreamData(get(), buf.data, buf.size_bytes));
  }
 
  int GetData(TargetBytes buf)
  {
    return SDL_GetAudioStreamData(get(), buf.data, buf.size_bytes);
  }
 
  int GetAvailable() const { return SDL_GetAudioStreamAvailable(get()); }
 
  int GetQueued() const { return SDL_GetAudioStreamQueued(get()); }
 
  void Flush() { CheckError(SDL_FlushAudioStream(get())); }
 
  void Clear() { CheckError(SDL_ClearAudioStream(get())); }
 
  void PauseDevice() { CheckError(SDL_PauseAudioStreamDevice(get())); }
 
  void ResumeDevice() { CheckError(SDL_ResumeAudioStreamDevice(get())); }
 
  bool DevicePaused() const { return SDL_AudioStreamDevicePaused(get()); }
 
  AudioStreamLock Lock();
  void SetGetCallback(AudioStreamCB callback);
 
  void SetGetCallback(AudioStreamCallback callback, void* userdata)
  {
    CheckError(SDL_SetAudioStreamGetCallback(get(), callback, userdata));
  }
 
  void SetPutCallback(AudioStreamCB callback);
 
  void SetPutCallback(AudioStreamCallback callback, void* userdata)
  {
    CheckError(SDL_SetAudioStreamPutCallback(get(), callback, userdata));
  }
 
  void Bind(AudioDeviceBase& devid) { devid.BindAudioStream(*this); }
 
  void Unbind() { SDL_UnbindAudioStream(get()); }
 
  AudioDeviceRef GetDevice() const { return SDL_GetAudioStreamDevice(get()); }
};
 
struct AudioStreamRef : AudioStreamBase
{
  using AudioStreamBase::AudioStreamBase;
 
  constexpr AudioStreamRef(const AudioStreamRef& other)
    : AudioStreamBase(other.get())
  {
  }
 
  constexpr AudioStreamRef(AudioStreamRef&& other)
    : AudioStreamBase(other.release())
  {
  }
 
  constexpr ~AudioStreamRef() = default;
 
  AudioStreamRef& operator=(AudioStreamRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_AudioStream* newResource = {})
  {
    KeyValueWrapper<SDL_AudioStream*, AudioStreamCB, 0>::release(get());
    KeyValueWrapper<SDL_AudioStream*, AudioStreamCB, 1>::release(get());
    SDL_DestroyAudioStream(release(newResource));
  }
};
 
struct AudioStream : AudioStreamRef
{
  using AudioStreamRef::AudioStreamRef;
 
  constexpr explicit AudioStream(SDL_AudioStream* resource = {})
    : AudioStreamRef(resource)
  {
  }
 
  constexpr AudioStream(const AudioStream& other) = delete;
 
  constexpr AudioStream(AudioStream&& other) = default;
 
  ~AudioStream() { reset(); }
 
  AudioStream& operator=(AudioStream other)
  {
    reset(other.release());
    return *this;
  }
};
 
struct AudioStreamLock : LockBase<AudioStreamRef>
{
  constexpr AudioStreamLock() = default;
 
  constexpr AudioStreamLock(AudioStreamLock&& other)
    : LockBase(other.release())
  {
  }
 
  AudioStreamLock(AudioStreamBase& stream)
    : LockBase(stream.get())
  {
    CheckError(SDL_LockAudioStream(stream.get()));
  }
 
  ~AudioStreamLock() { Unlock(); }
 
  void Unlock() { CheckError(SDL_UnlockAudioStream(release().get())); }
 
  void reset() { Unlock(); }
};
 
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 void AudioDeviceBase::BindAudioStreams(std::span<AudioStreamRef> streams)
{
  SDL_assert_paranoid(streams.size() < SDL_MAX_SINT32);
  CheckError(SDL_BindAudioStreams(
    get(),
    reinterpret_cast<SDL_AudioStream* const*>(streams.data()),
    streams.size()));
}
 
inline void AudioDeviceBase::BindAudioStream(AudioStreamBase& stream)
{
  CheckError(SDL_BindAudioStream(get(), stream.get()));
}
 
inline void UnbindAudioStreams(std::span<AudioStreamRef> streams)
{
  SDL_assert_paranoid(streams.size() < SDL_MAX_SINT32);
  SDL_UnbindAudioStreams(
    reinterpret_cast<SDL_AudioStream* const*>(streams.data()), streams.size());
}
 
inline AudioStreamLock AudioStreamBase::Lock()
{
  return AudioStreamLock(*this);
}
 
inline OwnArray<Uint8> LoadWAV(IOStreamBase& src, AudioSpec* spec)
{
  Uint8* buf;
  Uint32 len;
  if (!SDL_LoadWAV_IO(src.get(), false, 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)
{
  SDL_assert_paranoid(src.size_bytes < SDL_MAX_SINT32);
  CheckError(SDL_MixAudio(
    dst, static_cast<const Uint8*>(src.data), format, src.size_bytes, volume));
}
 
inline void MixAudio(TargetBytes dst,
                     SourceBytes src,
                     AudioFormat format,
                     float volume)
{
  if (dst.size_bytes < src.size_bytes) src.size_bytes = dst.size_bytes;
  MixAudio(static_cast<Uint8*>(dst.data), src, format, volume);
}
 
inline OwnArray<Uint8> ConvertAudioSamples(const AudioSpec& src_spec,
                                           SourceBytes src_data,
                                           const AudioSpec& dst_spec)
{
  SDL_assert_paranoid(src_data.size_bytes < SDL_MAX_SINT32);
  Uint8* buf;
  int len;
  CheckError(SDL_ConvertAudioSamples(&src_spec,
                                     static_cast<const Uint8*>(src_data.data),
                                     src_data.size_bytes,
                                     &dst_spec,
                                     &buf,
                                     &len));
  return OwnArray<Uint8>{buf, size_t(len)};
}
#pragma region impl
 
inline void AudioDeviceBase::SetPostmixCallback(AudioPostmixCB callback)
{
  using Wrapper = KeyValueCallbackWrapper<AudioDeviceRef, AudioPostmixCB>;
 
  auto cb = Wrapper::Wrap(get(), std::move(callback));
  if (!SDL_SetAudioPostmixCallback(
        get(),
        [](void* userdata, const AudioSpec* spec, float* buffer, int buflen) {
          Wrapper::Call(userdata, *spec, std::span{buffer, size_t(buflen)});
        },
        cb)) {
    Wrapper::release(get());
    throw Error{};
  }
}
 
inline void AudioStreamBase::SetGetCallback(AudioStreamCB callback)
{
  using Wrapper = KeyValueCallbackWrapper<SDL_AudioStream*, AudioStreamCB, 0>;
  if (!SDL_SetAudioStreamGetCallback(
        get(),
        [](void* userdata,
           SDL_AudioStream* stream,
           int additional_amount,
           int total_amount) {
          Wrapper::Call(userdata, stream, additional_amount, total_amount);
        },
        Wrapper::Wrap(get(), std::move(callback)))) {
    Wrapper::release(get());
    throw Error{};
  }
}
 
inline void AudioStreamBase::SetPutCallback(AudioStreamCB callback)
{
  using Wrapper = KeyValueCallbackWrapper<SDL_AudioStream*, AudioStreamCB, 1>;
  if (!SDL_SetAudioStreamPutCallback(
        get(),
        [](void* userdata,
           SDL_AudioStream* stream,
           int additional_amount,
           int total_amount) {
          Wrapper::Call(userdata, stream, additional_amount, total_amount);
        },
        Wrapper::Wrap(get(), std::move(callback)))) {
    Wrapper::release(get());
    throw Error{};
  }
}
 
#pragma endregion impl
} // namespace SDL
 
#endif /* SDL3PP_AUDIO_H_ */