SDL3pp_mixer.h

#ifndef SDL3PP_MIXER_H_
#define SDL3PP_MIXER_H_
 
#include "SDL3pp_audio.h"
#include "SDL3pp_version.h"
 
#if defined(SDL3PP_ENABLE_MIXER) || defined(SDL3PP_DOC)
 
#include <SDL3_mixer/SDL_mixer.h>
 
namespace SDL {
 
// Forward decl
struct Mixer;
 
using MixerRaw = MIX_Mixer*;
 
// Forward decl
struct MixerRef;
 
// Forward decl
struct Audio;
 
using AudioRaw = MIX_Audio*;
 
// Forward decl
struct AudioRef;
 
// Forward decl
struct Track;
 
using TrackRaw = MIX_Track*;
 
// Forward decl
struct TrackRef;
 
// Forward decl
struct Group;
 
using GroupRaw = MIX_Group*;
 
// Forward decl
struct GroupRef;
 
// Forward decl
struct AudioDecoder;
 
using AudioDecoderRaw = MIX_AudioDecoder*;
 
// Forward decl
struct AudioDecoderRef;
 
// Forward decl
struct MixerLock;
 
using PostMixCallback = void(SDLCALL*)(void* userdata,
                                       MixerRaw mixer,
                                       const AudioSpec* spec,
                                       float* pcm,
                                       int samples);
 
using PostMixCB = MakeFrontCallback<
  void(MixerRaw mixer, const AudioSpec* spec, float* pcm, int samples)>;
 
class Mixer
{
  MixerRaw m_resource = nullptr;
 
public:
  constexpr Mixer(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Mixer(MixerRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Mixer(const Mixer& other) noexcept = delete;
 
  constexpr Mixer(Mixer&& other) noexcept
    : Mixer(other.release())
  {
  }
 
  constexpr Mixer(const MixerRef& other) = delete;
 
  constexpr Mixer(MixerRef&& other) = delete;
 
  Mixer(AudioDeviceRef devid, const AudioSpec& spec);
 
  Mixer(const AudioSpec& spec);
 
  ~Mixer() { MIX_DestroyMixer(m_resource); }
 
  constexpr Mixer& operator=(Mixer&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Mixer& operator=(const Mixer& other) = delete;
 
  constexpr MixerRaw get() const noexcept { return m_resource; }
 
  constexpr MixerRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Mixer& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  PropertiesRef GetProperties();
 
  void GetFormat(AudioSpec* spec);
 
  MixerLock Lock();
 
  void Unlock(MixerLock&& lock);
 
  Audio LoadAudio_IO(IOStreamRef io, bool predecode, bool closeio = false);
 
  Audio LoadAudio(StringParam path, bool predecode);
 
  Audio LoadAudioNoCopy(SourceBytes data, bool free_when_done);
 
  Audio LoadRawAudio_IO(IOStreamRef io,
                        const AudioSpec& spec,
                        bool closeio = false);
 
  Audio LoadRawAudio(SourceBytes data, const AudioSpec& spec);
 
  Audio LoadRawAudioNoCopy(SourceBytes data,
                           const AudioSpec& spec,
                           bool free_when_done);
 
  Audio CreateSineWaveAudio(int hz, float amplitude, Sint64 ms);
 
  TrackRef CreateTrack();
 
  OwnArray<TrackRef> GetTaggedTracks(StringParam tag);
 
  void PlayTag(StringParam tag, PropertiesRef options);
 
  bool PlayAudio(AudioRef audio);
 
  void StopAllTracks(Sint64 fade_out_ms);
 
  void StopTag(StringParam tag, Sint64 fade_out_ms);
 
  void PauseAllTracks();
 
  void PauseTag(StringParam tag);
 
  void ResumeAllTracks();
 
  void ResumeTag(StringParam tag);
 
  void SetGain(float gain);
 
  float GetGain();
 
  void SetTagGain(StringParam tag, float gain);
 
  void SetFrequencyRatio(float ratio);
 
  float GetFrequencyRatio();
 
  GroupRef CreateGroup();
 
  void SetPostMixCallback(PostMixCallback cb, void* userdata);
 
  void SetPostMixCallback(PostMixCB cb);
 
  int Generate(TargetBytes buffer);
};
 
struct MixerRef : Mixer
{
  using Mixer::Mixer;
 
  constexpr MixerRef(MixerRaw resource) noexcept
    : Mixer(resource)
  {
  }
 
  constexpr MixerRef(const Mixer& resource) noexcept
    : Mixer(resource.get())
  {
  }
 
  constexpr MixerRef(Mixer&& resource) noexcept
    : Mixer(std::move(resource).release())
  {
  }
 
  constexpr MixerRef(const MixerRef& other) noexcept
    : Mixer(other.get())
  {
  }
 
  constexpr MixerRef(MixerRef&& other) noexcept
    : Mixer(other.get())
  {
  }
 
  ~MixerRef() { release(); }
 
  MixerRef& operator=(const MixerRef& other) noexcept
  {
    release();
    Mixer::operator=(Mixer(other.get()));
    return *this;
  }
 
  constexpr operator MixerRaw() const noexcept { return get(); }
};
 
class MixerLock
{
  MixerRef m_lock;
 
public:
  MixerLock(MixerRef resource);
 
  MixerLock(const MixerLock& other) = delete;
 
  MixerLock(MixerLock&& other) noexcept
    : m_lock(std::move(other.m_lock))
  {
  }
 
  ~MixerLock() { reset(); }
 
  MixerLock& operator=(const MixerLock& other) = delete;
 
  MixerLock& operator=(MixerLock&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    return *this;
  }
 
  constexpr operator bool() const { return bool(m_lock); }
 
  void reset();
 
  MixerRef resource() const { return m_lock; }
 
  void release() { m_lock.release(); }
};
 
class Audio
{
  AudioRaw m_resource = nullptr;
 
public:
  constexpr Audio(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Audio(AudioRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Audio(const Audio& other) noexcept = delete;
 
  constexpr Audio(Audio&& other) noexcept
    : Audio(other.release())
  {
  }
 
  constexpr Audio(const AudioRef& other) = delete;
 
  constexpr Audio(AudioRef&& other) = delete;
 
  Audio(MixerRef mixer, IOStreamRef io, bool predecode, bool closeio = false);
 
  Audio(MixerRef mixer, StringParam path, bool predecode);
 
  Audio(PropertiesRef props);
 
  Audio(MixerRef mixer,
        IOStreamRef io,
        const AudioSpec& spec,
        bool closeio = false);
 
  Audio(MixerRef mixer, SourceBytes data, const AudioSpec& spec);
 
  ~Audio() { MIX_DestroyAudio(m_resource); }
 
  constexpr Audio& operator=(Audio&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Audio& operator=(const Audio& other) = delete;
 
  constexpr AudioRaw get() const noexcept { return m_resource; }
 
  constexpr AudioRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Audio& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  PropertiesRef GetProperties();
 
  Sint64 GetDuration();
 
  void GetFormat(AudioSpec* spec);
 
  Sint64 MSToFrames(Milliseconds ms);
 
  Milliseconds FramesToMS(Sint64 frames);
};
 
struct AudioRef : Audio
{
  using Audio::Audio;
 
  constexpr AudioRef(AudioRaw resource) noexcept
    : Audio(resource)
  {
  }
 
  constexpr AudioRef(const Audio& resource) noexcept
    : Audio(resource.get())
  {
  }
 
  constexpr AudioRef(Audio&& resource) noexcept
    : Audio(std::move(resource).release())
  {
  }
 
  constexpr AudioRef(const AudioRef& other) noexcept
    : Audio(other.get())
  {
  }
 
  constexpr AudioRef(AudioRef&& other) noexcept
    : Audio(other.get())
  {
  }
 
  ~AudioRef() { release(); }
 
  AudioRef& operator=(const AudioRef& other) noexcept
  {
    release();
    Audio::operator=(Audio(other.get()));
    return *this;
  }
 
  constexpr operator AudioRaw() const noexcept { return get(); }
};
 
using StereoGains = MIX_StereoGains;
 
using Point3D = MIX_Point3D;
 
using TrackStoppedCallback = void(SDLCALL*)(void* userdata, TrackRaw track);
 
using TrackStoppedCB = MakeFrontCallback<void(TrackRaw track)>;
 
using TrackMixCallback = void(SDLCALL*)(void* userdata,
                                        TrackRaw track,
                                        const AudioSpec* spec,
                                        float* pcm,
                                        int samples);
 
using TrackMixCB = MakeFrontCallback<
  void(TrackRaw track, const AudioSpec* spec, float* pcm, int samples)>;
 
class Track
{
  TrackRaw m_resource = nullptr;
 
public:
  constexpr Track(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Track(TrackRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Track(const Track& other) noexcept = delete;
 
  constexpr Track(Track&& other) noexcept
    : Track(other.release())
  {
  }
 
  constexpr Track(const TrackRef& other) = delete;
 
  constexpr Track(TrackRef&& other) = delete;
 
  Track(MixerRef mixer);
 
  ~Track() { MIX_DestroyTrack(m_resource); }
 
  constexpr Track& operator=(Track&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Track& operator=(const Track& other) = delete;
 
  constexpr TrackRaw get() const noexcept { return m_resource; }
 
  constexpr TrackRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Track& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  PropertiesRef GetProperties();
 
  MixerRef GetMixer();
 
  void SetAudio(AudioRef audio);
 
  void SetAudioStream(AudioStreamRef stream);
 
  void SetIOStream(IOStreamRef io, bool closeio = false);
 
  void SetRawIOStream(IOStreamRef io,
                      const AudioSpec& spec,
                      bool closeio = false);
 
  void Tag(StringParam tag);
 
  void Untag(StringParam tag);
 
  OwnArray<char*> GetTags();
 
  void SetPlaybackPosition(Sint64 frames);
 
  Sint64 GetPlaybackPosition();
 
  Sint64 GetFadeFrames();
 
  int GetLoops();
 
  void SetLoops(int num_loops);
 
  AudioRef GetAudio();
 
  AudioStreamRef GetAudioStream();
 
  Sint64 GetRemaining();
 
  Sint64 MSToFrames(Milliseconds ms);
 
  Milliseconds FramesToMS(Sint64 frames);
 
  void Play(PropertiesRef options = nullptr);
 
  bool Stop(Sint64 fade_out_frames);
 
  bool Pause();
 
  bool Resume();
 
  bool Playing();
 
  bool Paused();
 
  void SetGain(float gain);
 
  float GetGain();
 
  void SetFrequencyRatio(float ratio);
 
  float GetFrequencyRatio();
 
  void SetOutputChannelMap(std::span<const int> chmap);
 
  void SetStereo(const StereoGains& gains);
 
  void Set3DPosition(const Point3D& position);
 
  Point3D Get3DPosition();
 
  void SetGroup(GroupRef group);
 
  void SetStoppedCallback(TrackStoppedCallback cb, void* userdata);
 
  void SetStoppedCallback(TrackStoppedCB cb);
 
  void SetRawCallback(TrackMixCallback cb, void* userdata);
 
  void SetRawCallback(TrackMixCB cb);
 
  void SetCookedCallback(TrackMixCallback cb, void* userdata);
 
  void SetCookedCallback(TrackMixCB cb);
};
 
struct TrackRef : Track
{
  using Track::Track;
 
  constexpr TrackRef(TrackRaw resource) noexcept
    : Track(resource)
  {
  }
 
  constexpr TrackRef(const Track& resource) noexcept
    : Track(resource.get())
  {
  }
 
  constexpr TrackRef(Track&& resource) noexcept
    : Track(std::move(resource).release())
  {
  }
 
  constexpr TrackRef(const TrackRef& other) noexcept
    : Track(other.get())
  {
  }
 
  constexpr TrackRef(TrackRef&& other) noexcept
    : Track(other.get())
  {
  }
 
  ~TrackRef() { release(); }
 
  TrackRef& operator=(const TrackRef& other) noexcept
  {
    release();
    Track::operator=(Track(other.get()));
    return *this;
  }
 
  constexpr operator TrackRaw() const noexcept { return get(); }
};
 
using GroupMixCallback = void(SDLCALL*)(void* userdata,
                                        GroupRaw group,
                                        const AudioSpec* spec,
                                        float* pcm,
                                        int samples);
 
using GroupMixCB = MakeFrontCallback<
  void(GroupRaw group, const AudioSpec* spec, float* pcm, int samples)>;
 
class Group
{
  GroupRaw m_resource = nullptr;
 
public:
  constexpr Group(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Group(GroupRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Group(const Group& other) noexcept = delete;
 
  constexpr Group(Group&& other) noexcept
    : Group(other.release())
  {
  }
 
  constexpr Group(const GroupRef& other) = delete;
 
  constexpr Group(GroupRef&& other) = delete;
 
  Group(MixerRef mixer);
 
  ~Group() { MIX_DestroyGroup(m_resource); }
 
  constexpr Group& operator=(Group&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Group& operator=(const Group& other) = delete;
 
  constexpr GroupRaw get() const noexcept { return m_resource; }
 
  constexpr GroupRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Group& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  PropertiesRef GetProperties();
 
  MixerRef GetMixer();
 
  void SetPostMixCallback(GroupMixCallback cb, void* userdata);
};
 
struct GroupRef : Group
{
  using Group::Group;
 
  constexpr GroupRef(GroupRaw resource) noexcept
    : Group(resource)
  {
  }
 
  constexpr GroupRef(const Group& resource) noexcept
    : Group(resource.get())
  {
  }
 
  constexpr GroupRef(Group&& resource) noexcept
    : Group(std::move(resource).release())
  {
  }
 
  constexpr GroupRef(const GroupRef& other) noexcept
    : Group(other.get())
  {
  }
 
  constexpr GroupRef(GroupRef&& other) noexcept
    : Group(other.get())
  {
  }
 
  ~GroupRef() { release(); }
 
  GroupRef& operator=(const GroupRef& other) noexcept
  {
    release();
    Group::operator=(Group(other.get()));
    return *this;
  }
 
  constexpr operator GroupRaw() const noexcept { return get(); }
};
 
#ifdef SDL3PP_DOC
 
#define SDL_MIXER_MAJOR_VERSION
 
#define SDL_MIXER_MINOR_VERSION
 
#define SDL_MIXER_MICRO_VERSION
 
#define SDL_MIXER_VERSION                                                      \
  SDL_VERSIONNUM(                                                              \
    SDL_MIXER_MAJOR_VERSION, SDL_MIXER_MINOR_VERSION, SDL_MIXER_MICRO_VERSION)
 
#define SDL_MIXER_VERSION_ATLEAST(X, Y, Z)                                     \
  ((SDL_MIXER_MAJOR_VERSION >= X) &&                                           \
   (SDL_MIXER_MAJOR_VERSION > X || SDL_MIXER_MINOR_VERSION >= Y) &&            \
   (SDL_MIXER_MAJOR_VERSION > X || SDL_MIXER_MINOR_VERSION > Y ||              \
    SDL_MIXER_MICRO_VERSION >= Z))
 
#endif // SDL3PP_DOC
 
namespace MIX {
 
inline int Version() { return MIX_Version(); }
 
inline void Init() { CheckError(MIX_Init()); }
 
inline void Quit() { MIX_Quit(); }
 
} // namespace MIX
 
inline int GetNumAudioDecoders() { return MIX_GetNumAudioDecoders(); }
 
inline const char* GetAudioDecoder(int index)
{
  return MIX_GetAudioDecoder(index);
}
 
inline Mixer CreateMixerDevice(AudioDeviceRef devid, const AudioSpec& spec)
{
  return Mixer(devid, spec);
}
 
inline Mixer::Mixer(AudioDeviceRef devid, const AudioSpec& spec)
  : m_resource(CheckError(MIX_CreateMixerDevice(devid, &spec)))
{
}
 
inline Mixer::Mixer(const AudioSpec& spec)
  : m_resource(CheckError(MIX_CreateMixer(&spec)))
{
}
 
inline Mixer CreateMixer(const AudioSpec& spec) { return Mixer(spec); }
 
inline void DestroyMixer(MixerRaw mixer) { MIX_DestroyMixer(mixer); }
 
inline void Mixer::Destroy() { DestroyMixer(release()); }
 
inline PropertiesRef GetMixerProperties(MixerRef mixer)
{
  return CheckError(MIX_GetMixerProperties(mixer));
}
 
inline PropertiesRef Mixer::GetProperties()
{
  return SDL::GetMixerProperties(m_resource);
}
 
namespace prop::Mixer {
 
constexpr auto DEVICE_NUMBER = MIX_PROP_MIXER_DEVICE_NUMBER;
 
} // namespace prop::Mixer
 
inline void GetMixerFormat(MixerRef mixer, AudioSpec* spec)
{
  CheckError(MIX_GetMixerFormat(mixer, spec));
}
 
inline void Mixer::GetFormat(AudioSpec* spec)
{
  SDL::GetMixerFormat(m_resource, spec);
}
 
inline void LockMixer(MixerRef mixer) { MIX_LockMixer(mixer); }
 
inline MixerLock Mixer::Lock() { return {MixerRef(*this)}; }
 
inline MixerLock::MixerLock(MixerRef resource)
  : m_lock(std::move(resource))
{
  LockMixer(m_lock);
}
 
inline void UnlockMixer(MixerRef mixer) { MIX_UnlockMixer(mixer); }
 
inline void Mixer::Unlock(MixerLock&& lock)
{
  SDL_assert_paranoid(lock.resource() == *this);
  std::move(lock).reset();
}
 
inline void MixerLock::reset()
{
  if (!m_lock) return;
  UnlockMixer(m_lock);
  m_lock = {};
}
 
inline Audio LoadAudio_IO(MixerRef mixer,
                          IOStreamRef io,
                          bool predecode,
                          bool closeio = false)
{
  return Audio(mixer, io, predecode, closeio);
}
 
inline Audio Mixer::LoadAudio_IO(IOStreamRef io, bool predecode, bool closeio)
{
  return Audio(m_resource, io, predecode, closeio);
}
 
inline Audio::Audio(MixerRef mixer,
                    IOStreamRef io,
                    bool predecode,
                    bool closeio)
  : m_resource(MIX_LoadAudio_IO(mixer, io, predecode, closeio))
{
}
 
inline Audio::Audio(MixerRef mixer, StringParam path, bool predecode)
  : m_resource(MIX_LoadAudio(mixer, path, predecode))
{
}
 
inline Audio::Audio(PropertiesRef props)
  : m_resource(CheckError(MIX_LoadAudioWithProperties(props)))
{
}
 
inline Audio::Audio(MixerRef mixer,
                    IOStreamRef io,
                    const AudioSpec& spec,
                    bool closeio)
  : m_resource(CheckError(MIX_LoadRawAudio_IO(mixer, io, &spec, closeio)))
{
}
 
inline Audio::Audio(MixerRef mixer, SourceBytes data, const AudioSpec& spec)
  : m_resource(CheckError(
      MIX_LoadRawAudio(mixer, data.data(), data.size_bytes(), &spec)))
{
}
 
inline Audio LoadAudio(MixerRef mixer, StringParam path, bool predecode)
{
  return Audio(mixer, std::move(path), predecode);
}
 
inline Audio Mixer::LoadAudio(StringParam path, bool predecode)
{
  return Audio(m_resource, std::move(path), predecode);
}
 
inline Audio LoadAudioNoCopy(MixerRef mixer,
                             SourceBytes data,
                             bool free_when_done)
{
  return Audio(CheckError(MIX_LoadAudioNoCopy(
    mixer, data.data(), data.size_bytes(), free_when_done)));
}
 
inline Audio Mixer::LoadAudioNoCopy(SourceBytes data, bool free_when_done)
{
  return SDL::LoadAudioNoCopy(m_resource, std::move(data), free_when_done);
}
 
inline Audio LoadAudioWithProperties(PropertiesRef props)
{
  return Audio(props);
}
 
namespace prop::Audio {
 
constexpr auto LOAD_IOSTREAM_POINTER = MIX_PROP_AUDIO_LOAD_IOSTREAM_POINTER;
 
constexpr auto LOAD_CLOSEIO_BOOLEAN = MIX_PROP_AUDIO_LOAD_CLOSEIO_BOOLEAN;
 
constexpr auto LOAD_PREDECODE_BOOLEAN = MIX_PROP_AUDIO_LOAD_PREDECODE_BOOLEAN;
 
constexpr auto LOAD_PREFERRED_MIXER_POINTER =
  MIX_PROP_AUDIO_LOAD_PREFERRED_MIXER_POINTER;
 
constexpr auto LOAD_SKIP_METADATA_TAGS_BOOLEAN =
  MIX_PROP_AUDIO_LOAD_SKIP_METADATA_TAGS_BOOLEAN;
 
constexpr auto DECODER_STRING = MIX_PROP_AUDIO_DECODER_STRING;
 
} // namespace prop::Audio
 
inline Audio LoadRawAudio_IO(MixerRef mixer,
                             IOStreamRef io,
                             const AudioSpec& spec,
                             bool closeio = false)
{
  return Audio(mixer, io, spec, closeio);
}
 
inline Audio Mixer::LoadRawAudio_IO(IOStreamRef io,
                                    const AudioSpec& spec,
                                    bool closeio)
{
  return Audio(m_resource, io, spec, closeio);
}
 
inline Audio LoadRawAudio(MixerRef mixer,
                          SourceBytes data,
                          const AudioSpec& spec)
{
  return Audio(mixer, std::move(data), spec);
}
 
inline Audio Mixer::LoadRawAudio(SourceBytes data, const AudioSpec& spec)
{
  return Audio(m_resource, std::move(data), spec);
}
 
inline Audio LoadRawAudioNoCopy(MixerRef mixer,
                                SourceBytes data,
                                const AudioSpec& spec,
                                bool free_when_done)
{
  return Audio(CheckError(MIX_LoadRawAudioNoCopy(
    mixer, data.data(), data.size_bytes(), &spec, free_when_done)));
}
 
inline Audio Mixer::LoadRawAudioNoCopy(SourceBytes data,
                                       const AudioSpec& spec,
                                       bool free_when_done)
{
  return SDL::LoadRawAudioNoCopy(
    m_resource, std::move(data), spec, free_when_done);
}
 
inline Audio CreateSineWaveAudio(MixerRef mixer,
                                 int hz,
                                 float amplitude,
                                 Sint64 ms)
{
  return Audio(CheckError(MIX_CreateSineWaveAudio(mixer, hz, amplitude, ms)));
}
 
inline Audio Mixer::CreateSineWaveAudio(int hz, float amplitude, Sint64 ms)
{
  return SDL::CreateSineWaveAudio(m_resource, hz, amplitude, ms);
}
 
inline PropertiesRef GetAudioProperties(AudioRef audio)
{
  return CheckError(MIX_GetAudioProperties(audio));
}
 
inline PropertiesRef Audio::GetProperties()
{
  return SDL::GetAudioProperties(m_resource);
}
 
namespace prop::MixMetadata {
 
constexpr auto TITLE_STRING = MIX_PROP_METADATA_TITLE_STRING;
 
constexpr auto ARTIST_STRING = MIX_PROP_METADATA_ARTIST_STRING;
 
constexpr auto ALBUM_STRING = MIX_PROP_METADATA_ALBUM_STRING;
 
constexpr auto COPYRIGHT_STRING = MIX_PROP_METADATA_COPYRIGHT_STRING;
 
constexpr auto TRACK_NUMBER = MIX_PROP_METADATA_TRACK_NUMBER;
 
constexpr auto TOTAL_TRACKS_NUMBER = MIX_PROP_METADATA_TOTAL_TRACKS_NUMBER;
 
constexpr auto YEAR_NUMBER = MIX_PROP_METADATA_YEAR_NUMBER;
 
constexpr auto DURATION_FRAMES_NUMBER =
  MIX_PROP_METADATA_DURATION_FRAMES_NUMBER;
 
constexpr auto DURATION_INFINITE_BOOLEAN =
  MIX_PROP_METADATA_DURATION_INFINITE_BOOLEAN;
 
} // namespace prop::MixMetadata
 
inline Sint64 GetAudioDuration(AudioRef audio)
{
  return MIX_GetAudioDuration(audio);
}
 
inline Sint64 Audio::GetDuration() { return SDL::GetAudioDuration(m_resource); }
 
constexpr Sint64 DURATION_UNKNOWN = MIX_DURATION_UNKNOWN;
 
constexpr Sint64 DURATION_INFINITE = MIX_DURATION_INFINITE;
 
inline void GetAudioFormat(AudioRef audio, AudioSpec* spec)
{
  CheckError(MIX_GetAudioFormat(audio, spec));
}
 
inline void Audio::GetFormat(AudioSpec* spec)
{
  SDL::GetAudioFormat(m_resource, spec);
}
 
inline void DestroyAudio(AudioRaw audio) { MIX_DestroyAudio(audio); }
 
inline void Audio::Destroy() { DestroyAudio(release()); }
 
inline Track CreateTrack(MixerRef mixer) { return Track(mixer); }
 
inline TrackRef Mixer::CreateTrack() { return Track(m_resource); }
 
inline Track::Track(MixerRef mixer)
  : m_resource(CheckError(MIX_CreateTrack(mixer)))
{
}
 
inline void DestroyTrack(TrackRaw track) { MIX_DestroyTrack(track); }
 
inline void Track::Destroy() { DestroyTrack(release()); }
 
inline PropertiesRef GetTrackProperties(TrackRef track)
{
  return CheckError(MIX_GetTrackProperties(track));
}
 
inline PropertiesRef Track::GetProperties()
{
  return SDL::GetTrackProperties(m_resource);
}
 
inline MixerRef GetTrackMixer(TrackRef track)
{
  return CheckError(MIX_GetTrackMixer(track));
}
 
inline MixerRef Track::GetMixer() { return SDL::GetTrackMixer(m_resource); }
 
inline void SetTrackAudio(TrackRef track, AudioRef audio)
{
  CheckError(MIX_SetTrackAudio(track, audio));
}
 
inline void Track::SetAudio(AudioRef audio)
{
  SDL::SetTrackAudio(m_resource, audio);
}
 
inline void SetTrackAudioStream(TrackRef track, AudioStreamRef stream)
{
  CheckError(MIX_SetTrackAudioStream(track, stream));
}
 
inline void Track::SetAudioStream(AudioStreamRef stream)
{
  SDL::SetTrackAudioStream(m_resource, stream);
}
 
inline void SetTrackIOStream(TrackRef track,
                             IOStreamRef io,
                             bool closeio = false)
{
  CheckError(MIX_SetTrackIOStream(track, io, closeio));
}
 
inline void Track::SetIOStream(IOStreamRef io, bool closeio)
{
  SDL::SetTrackIOStream(m_resource, io, closeio);
}
 
inline void SetTrackRawIOStream(TrackRef track,
                                IOStreamRef io,
                                const AudioSpec& spec,
                                bool closeio = false)
{
  CheckError(MIX_SetTrackRawIOStream(track, io, &spec, closeio));
}
 
inline void Track::SetRawIOStream(IOStreamRef io,
                                  const AudioSpec& spec,
                                  bool closeio)
{
  SDL::SetTrackRawIOStream(m_resource, io, spec, closeio);
}
 
inline void TagTrack(TrackRef track, StringParam tag)
{
  CheckError(MIX_TagTrack(track, tag));
}
 
inline void Track::Tag(StringParam tag)
{
  SDL::TagTrack(m_resource, std::move(tag));
}
 
inline void UntagTrack(TrackRef track, StringParam tag)
{
  MIX_UntagTrack(track, tag);
}
 
inline void Track::Untag(StringParam tag)
{
  SDL::UntagTrack(m_resource, std::move(tag));
}
 
inline OwnArray<char*> GetTrackTags(TrackRef track)
{
  int count;
  auto result = CheckError(MIX_GetTrackTags(track, &count));
  return OwnArray<char*>(result, count);
}
 
inline OwnArray<char*> Track::GetTags()
{
  return SDL::GetTrackTags(m_resource);
}
 
inline OwnArray<TrackRef> GetTaggedTracks(MixerRef mixer, StringParam tag)
{
  int count;
  auto result = CheckError(MIX_GetTaggedTracks(mixer, tag, &count));
  return OwnArray<TrackRef>(reinterpret_cast<TrackRef*>(result), count);
}
 
inline OwnArray<TrackRef> Mixer::GetTaggedTracks(StringParam tag)
{
  return SDL::GetTaggedTracks(m_resource, std::move(tag));
}
 
inline void SetTrackPlaybackPosition(TrackRef track, Sint64 frames)
{
  CheckError(MIX_SetTrackPlaybackPosition(track, frames));
}
 
inline void Track::SetPlaybackPosition(Sint64 frames)
{
  SDL::SetTrackPlaybackPosition(m_resource, frames);
}
 
inline Sint64 GetTrackPlaybackPosition(TrackRef track)
{
  return MIX_GetTrackPlaybackPosition(track);
}
 
inline Sint64 Track::GetPlaybackPosition()
{
  return SDL::GetTrackPlaybackPosition(m_resource);
}
 
inline Sint64 GetTrackFadeFrames(TrackRef track)
{
  return MIX_GetTrackFadeFrames(track);
}
 
inline Sint64 Track::GetFadeFrames()
{
  return SDL::GetTrackFadeFrames(m_resource);
}
 
inline int GetTrackLoops(TrackRef track) { return MIX_GetTrackLoops(track); }
 
inline int Track::GetLoops() { return SDL::GetTrackLoops(m_resource); }
 
inline void SetTrackLoops(TrackRef track, int num_loops)
{
  CheckError(MIX_SetTrackLoops(track, num_loops));
}
 
inline void Track::SetLoops(int num_loops)
{
  SDL::SetTrackLoops(m_resource, num_loops);
}
 
inline AudioRef GetTrackAudio(TrackRef track)
{
  return MIX_GetTrackAudio(track);
}
 
inline AudioRef Track::GetAudio() { return SDL::GetTrackAudio(m_resource); }
 
inline AudioStreamRef GetTrackAudioStream(TrackRef track)
{
  return MIX_GetTrackAudioStream(track);
}
 
inline AudioStreamRef Track::GetAudioStream()
{
  return SDL::GetTrackAudioStream(m_resource);
}
 
inline Sint64 GetTrackRemaining(TrackRef track)
{
  return MIX_GetTrackRemaining(track);
}
 
inline Sint64 Track::GetRemaining()
{
  return SDL::GetTrackRemaining(m_resource);
}
 
inline Sint64 TrackMSToFrames(TrackRef track, Milliseconds ms)
{
  return MIX_TrackMSToFrames(track, ms.count());
}
 
inline Sint64 Track::MSToFrames(Milliseconds ms)
{
  return SDL::TrackMSToFrames(m_resource, ms);
}
 
inline Milliseconds TrackFramesToMS(TrackRef track, Sint64 frames)
{
  return Milliseconds(MIX_TrackFramesToMS(track, frames));
}
 
inline Milliseconds Track::FramesToMS(Sint64 frames)
{
  return SDL::TrackFramesToMS(m_resource, frames);
}
 
inline Sint64 AudioMSToFrames(AudioRef audio, Milliseconds ms)
{
  return MIX_AudioMSToFrames(audio, ms.count());
}
 
inline Sint64 Audio::MSToFrames(Milliseconds ms)
{
  return SDL::AudioMSToFrames(m_resource, ms);
}
 
inline Milliseconds AudioFramesToMS(AudioRef audio, Sint64 frames)
{
  return Milliseconds(MIX_AudioFramesToMS(audio, frames));
}
 
inline Milliseconds Audio::FramesToMS(Sint64 frames)
{
  return SDL::AudioFramesToMS(m_resource, frames);
}
 
inline Sint64 MSToFrames(int sample_rate, Milliseconds ms)
{
  return MIX_MSToFrames(sample_rate, ms.count());
}
 
inline Milliseconds FramesToMS(int sample_rate, Sint64 frames)
{
  return Milliseconds(MIX_FramesToMS(sample_rate, frames));
}
 
inline void PlayTrack(TrackRef track, PropertiesRef options = nullptr)
{
  CheckError(MIX_PlayTrack(track, options));
}
 
inline void Track::Play(PropertiesRef options)
{
  SDL::PlayTrack(m_resource, options);
}
 
namespace prop::Play {
 
constexpr auto LOOPS_NUMBER = MIX_PROP_PLAY_LOOPS_NUMBER;
 
constexpr auto MAX_FRAME_NUMBER = MIX_PROP_PLAY_MAX_FRAME_NUMBER;
 
constexpr auto MAX_MILLISECONDS_NUMBER = MIX_PROP_PLAY_MAX_MILLISECONDS_NUMBER;
 
constexpr auto START_FRAME_NUMBER = MIX_PROP_PLAY_START_FRAME_NUMBER;
 
constexpr auto START_MILLISECOND_NUMBER =
  MIX_PROP_PLAY_START_MILLISECOND_NUMBER;
 
constexpr auto LOOP_START_FRAME_NUMBER = MIX_PROP_PLAY_LOOP_START_FRAME_NUMBER;
 
constexpr auto LOOP_START_MILLISECOND_NUMBER =
  MIX_PROP_PLAY_LOOP_START_MILLISECOND_NUMBER;
 
constexpr auto FADE_IN_FRAMES_NUMBER = MIX_PROP_PLAY_FADE_IN_FRAMES_NUMBER;
 
constexpr auto FADE_IN_MILLISECONDS_NUMBER =
  MIX_PROP_PLAY_FADE_IN_MILLISECONDS_NUMBER;
 
constexpr auto FADE_IN_START_GAIN_FLOAT =
  MIX_PROP_PLAY_FADE_IN_START_GAIN_FLOAT;
 
constexpr auto APPEND_SILENCE_FRAMES_NUMBER =
  MIX_PROP_PLAY_APPEND_SILENCE_FRAMES_NUMBER;
 
constexpr auto APPEND_SILENCE_MILLISECONDS_NUMBER =
  MIX_PROP_PLAY_APPEND_SILENCE_MILLISECONDS_NUMBER;
 
constexpr auto HALT_WHEN_EXHAUSTED_BOOLEAN =
  MIX_PROP_PLAY_HALT_WHEN_EXHAUSTED_BOOLEAN;
 
} // namespace prop::Play
 
inline void PlayTag(MixerRef mixer, StringParam tag, PropertiesRef options)
{
  CheckError(MIX_PlayTag(mixer, tag, options));
}
 
inline void Mixer::PlayTag(StringParam tag, PropertiesRef options)
{
  SDL::PlayTag(m_resource, std::move(tag), options);
}
 
inline bool PlayAudio(MixerRef mixer, AudioRef audio)
{
  return MIX_PlayAudio(mixer, audio);
}
 
inline bool Mixer::PlayAudio(AudioRef audio)
{
  return SDL::PlayAudio(m_resource, audio);
}
 
inline bool StopTrack(TrackRef track, Sint64 fade_out_frames)
{
  return MIX_StopTrack(track, fade_out_frames);
}
 
inline bool Track::Stop(Sint64 fade_out_frames)
{
  return SDL::StopTrack(m_resource, fade_out_frames);
}
 
inline void StopAllTracks(MixerRef mixer, Sint64 fade_out_ms)
{
  CheckError(MIX_StopAllTracks(mixer, fade_out_ms));
}
 
inline void Mixer::StopAllTracks(Sint64 fade_out_ms)
{
  SDL::StopAllTracks(m_resource, fade_out_ms);
}
 
inline void StopTag(MixerRef mixer, StringParam tag, Sint64 fade_out_ms)
{
  CheckError(MIX_StopTag(mixer, tag, fade_out_ms));
}
 
inline void Mixer::StopTag(StringParam tag, Sint64 fade_out_ms)
{
  SDL::StopTag(m_resource, std::move(tag), fade_out_ms);
}
 
inline bool PauseTrack(TrackRef track) { return MIX_PauseTrack(track); }
 
inline bool Track::Pause() { return SDL::PauseTrack(m_resource); }
 
inline void PauseAllTracks(MixerRef mixer)
{
  CheckError(MIX_PauseAllTracks(mixer));
}
 
inline void Mixer::PauseAllTracks() { SDL::PauseAllTracks(m_resource); }
 
inline void PauseTag(MixerRef mixer, StringParam tag)
{
  CheckError(MIX_PauseTag(mixer, tag));
}
 
inline void Mixer::PauseTag(StringParam tag)
{
  SDL::PauseTag(m_resource, std::move(tag));
}
 
inline bool ResumeTrack(TrackRef track) { return MIX_ResumeTrack(track); }
 
inline bool Track::Resume() { return SDL::ResumeTrack(m_resource); }
 
inline void ResumeAllTracks(MixerRef mixer)
{
  CheckError(MIX_ResumeAllTracks(mixer));
}
 
inline void Mixer::ResumeAllTracks() { SDL::ResumeAllTracks(m_resource); }
 
inline void ResumeTag(MixerRef mixer, StringParam tag)
{
  CheckError(MIX_ResumeTag(mixer, tag));
}
 
inline void Mixer::ResumeTag(StringParam tag)
{
  SDL::ResumeTag(m_resource, std::move(tag));
}
 
inline bool TrackPlaying(TrackRef track) { return MIX_TrackPlaying(track); }
 
inline bool Track::Playing() { return SDL::TrackPlaying(m_resource); }
 
inline bool TrackPaused(TrackRef track) { return MIX_TrackPaused(track); }
 
inline bool Track::Paused() { return SDL::TrackPaused(m_resource); }
 
inline void SetMixerGain(MixerRef mixer, float gain)
{
  CheckError(MIX_SetMixerGain(mixer, gain));
}
 
inline void Mixer::SetGain(float gain) { SDL::SetMixerGain(m_resource, gain); }
 
inline float GetMixerGain(MixerRef mixer) { return MIX_GetMixerGain(mixer); }
 
inline float Mixer::GetGain() { return SDL::GetMixerGain(m_resource); }
 
inline void SetTrackGain(TrackRef track, float gain)
{
  CheckError(MIX_SetTrackGain(track, gain));
}
 
inline void Track::SetGain(float gain) { SDL::SetTrackGain(m_resource, gain); }
 
inline float GetTrackGain(TrackRef track) { return MIX_GetTrackGain(track); }
 
inline float Track::GetGain() { return SDL::GetTrackGain(m_resource); }
 
inline void SetTagGain(MixerRef mixer, StringParam tag, float gain)
{
  CheckError(MIX_SetTagGain(mixer, tag, gain));
}
 
inline void Mixer::SetTagGain(StringParam tag, float gain)
{
  SDL::SetTagGain(m_resource, std::move(tag), gain);
}
 
inline void SetMixerFrequencyRatio(MixerRef mixer, float ratio)
{
  CheckError(MIX_SetMixerFrequencyRatio(mixer, ratio));
}
 
inline void Mixer::SetFrequencyRatio(float ratio)
{
  SDL::SetMixerFrequencyRatio(m_resource, ratio);
}
 
inline float GetMixerFrequencyRatio(MixerRef mixer)
{
  return MIX_GetMixerFrequencyRatio(mixer);
}
 
inline float Mixer::GetFrequencyRatio()
{
  return SDL::GetMixerFrequencyRatio(m_resource);
}
 
inline void SetTrackFrequencyRatio(TrackRef track, float ratio)
{
  CheckError(MIX_SetTrackFrequencyRatio(track, ratio));
}
 
inline void Track::SetFrequencyRatio(float ratio)
{
  SDL::SetTrackFrequencyRatio(m_resource, ratio);
}
 
inline float GetTrackFrequencyRatio(TrackRef track)
{
  return MIX_GetTrackFrequencyRatio(track);
}
 
inline float Track::GetFrequencyRatio()
{
  return SDL::GetTrackFrequencyRatio(m_resource);
}
 
inline void SetTrackOutputChannelMap(TrackRef track, std::span<const int> chmap)
{
  CheckError(
    MIX_SetTrackOutputChannelMap(track, chmap.data(), narrowS32(chmap.size())));
}
 
inline void Track::SetOutputChannelMap(std::span<const int> chmap)
{
  SDL::SetTrackOutputChannelMap(m_resource, chmap);
}
 
inline void SetTrackStereo(TrackRef track, const StereoGains& gains)
{
  CheckError(MIX_SetTrackStereo(track, &gains));
}
 
inline void Track::SetStereo(const StereoGains& gains)
{
  SDL::SetTrackStereo(m_resource, gains);
}
 
inline void SetTrack3DPosition(TrackRef track, const Point3D& position)
{
  CheckError(MIX_SetTrack3DPosition(track, &position));
}
 
inline void Track::Set3DPosition(const Point3D& position)
{
  SDL::SetTrack3DPosition(m_resource, position);
}
 
inline Point3D GetTrack3DPosition(TrackRef track)
{
  Point3D position;
  CheckError(MIX_GetTrack3DPosition(track, &position));
  return position;
}
 
inline Point3D Track::Get3DPosition()
{
  return SDL::GetTrack3DPosition(m_resource);
}
 
inline Group CreateGroup(MixerRef mixer) { return Group(mixer); }
 
inline GroupRef Mixer::CreateGroup() { return Group(m_resource); }
 
inline Group::Group(MixerRef mixer)
  : m_resource(CheckError(MIX_CreateGroup(mixer)))
{
}
 
inline void DestroyGroup(GroupRaw group) { MIX_DestroyGroup(group); }
 
inline void Group::Destroy() { DestroyGroup(release()); }
 
inline PropertiesRef GetGroupProperties(GroupRef group)
{
  return CheckError(MIX_GetGroupProperties(group));
}
 
inline PropertiesRef Group::GetProperties()
{
  return SDL::GetGroupProperties(m_resource);
}
 
inline MixerRef GetGroupMixer(GroupRef group)
{
  return CheckError(MIX_GetGroupMixer(group));
}
 
inline MixerRef Group::GetMixer() { return SDL::GetGroupMixer(m_resource); }
 
inline void SetTrackGroup(TrackRef track, GroupRef group)
{
  CheckError(MIX_SetTrackGroup(track, group));
}
 
inline void Track::SetGroup(GroupRef group)
{
  SDL::SetTrackGroup(m_resource, group);
}
 
inline void SetTrackStoppedCallback(TrackRef track,
                                    TrackStoppedCallback cb,
                                    void* userdata)
{
  CheckError(MIX_SetTrackStoppedCallback(track, cb, userdata));
}
 
inline void SetTrackStoppedCallback(TrackRef track, TrackStoppedCB cb)
{
  SetTrackStoppedCallback(track, cb.wrapper, cb.data);
}
 
inline void Track::SetStoppedCallback(TrackStoppedCallback cb, void* userdata)
{
  SDL::SetTrackStoppedCallback(m_resource, cb, userdata);
}
 
inline void Track::SetStoppedCallback(TrackStoppedCB cb)
{
  SDL::SetTrackStoppedCallback(m_resource, cb);
}
 
inline void SetTrackRawCallback(TrackRef track,
                                TrackMixCallback cb,
                                void* userdata)
{
  CheckError(MIX_SetTrackRawCallback(track, cb, userdata));
}
 
inline void SetTrackRawCallback(TrackRef track, TrackMixCB cb)
{
  SetTrackRawCallback(track, cb.wrapper, cb.data);
}
 
inline void Track::SetRawCallback(TrackMixCallback cb, void* userdata)
{
  SDL::SetTrackRawCallback(m_resource, cb, userdata);
}
 
inline void Track::SetRawCallback(TrackMixCB cb)
{
  SDL::SetTrackRawCallback(m_resource, cb);
}
 
inline void SetTrackCookedCallback(TrackRef track,
                                   TrackMixCallback cb,
                                   void* userdata)
{
  CheckError(MIX_SetTrackCookedCallback(track, cb, userdata));
}
 
inline void SetTrackCookedCallback(TrackRef track, TrackMixCB cb)
{
  SetTrackCookedCallback(track, cb.wrapper, cb.data);
}
 
inline void Track::SetCookedCallback(TrackMixCallback cb, void* userdata)
{
  SDL::SetTrackCookedCallback(m_resource, cb, userdata);
}
 
inline void Track::SetCookedCallback(TrackMixCB cb)
{
  SDL::SetTrackCookedCallback(m_resource, cb);
}
 
inline void SetGroupPostMixCallback(GroupRef group,
                                    GroupMixCallback cb,
                                    void* userdata)
{
  CheckError(MIX_SetGroupPostMixCallback(group, cb, userdata));
}
 
inline void SetGroupPostMixCallback(GroupRef group, GroupMixCB cb)
{
  SetGroupPostMixCallback(group, cb.wrapper, cb.data);
}
 
inline void Group::SetPostMixCallback(GroupMixCallback cb, void* userdata)
{
  SDL::SetGroupPostMixCallback(m_resource, cb, userdata);
}
 
inline void SetPostMixCallback(MixerRef mixer,
                               PostMixCallback cb,
                               void* userdata)
{
  CheckError(MIX_SetPostMixCallback(mixer, cb, userdata));
}
 
inline void SetPostMixCallback(MixerRef mixer, PostMixCB cb)
{
  SetPostMixCallback(mixer, cb.wrapper, cb.data);
}
 
inline void Mixer::SetPostMixCallback(PostMixCallback cb, void* userdata)
{
  SDL::SetPostMixCallback(m_resource, cb, userdata);
}
 
inline void Mixer::SetPostMixCallback(PostMixCB cb)
{
  SDL::SetPostMixCallback(m_resource, cb);
}
 
inline int Generate(MixerRef mixer, TargetBytes buffer)
{
  return CheckError(
    MIX_Generate(mixer, buffer.data(), narrowS32(buffer.size_bytes())), -1);
}
 
inline int Mixer::Generate(TargetBytes buffer)
{
  return SDL::Generate(m_resource, std::move(buffer));
}
 
class AudioDecoder
{
  AudioDecoderRaw m_resource = nullptr;
 
public:
  constexpr AudioDecoder(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit AudioDecoder(AudioDecoderRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr AudioDecoder(const AudioDecoder& other) noexcept = delete;
 
  constexpr AudioDecoder(AudioDecoder&& other) noexcept
    : AudioDecoder(other.release())
  {
  }
 
  constexpr AudioDecoder(const AudioDecoderRef& other) = delete;
 
  constexpr AudioDecoder(AudioDecoderRef&& other) = delete;
 
  AudioDecoder(StringParam path, PropertiesRef props = nullptr);
 
  AudioDecoder(IOStreamRef io,
               bool closeio = false,
               PropertiesRef props = nullptr);
 
  ~AudioDecoder() { MIX_DestroyAudioDecoder(m_resource); }
 
  constexpr AudioDecoder& operator=(AudioDecoder&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  AudioDecoder& operator=(const AudioDecoder& other) = delete;
 
  constexpr AudioDecoderRaw get() const noexcept { return m_resource; }
 
  constexpr AudioDecoderRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const AudioDecoder& other) const noexcept =
    default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  PropertiesRef GetProperties();
 
  void GetFormat(AudioSpec* spec);
 
  int DecodeAudio(TargetBytes buffer, const AudioSpec& spec);
};
 
struct AudioDecoderRef : AudioDecoder
{
  using AudioDecoder::AudioDecoder;
 
  constexpr AudioDecoderRef(AudioDecoderRaw resource) noexcept
    : AudioDecoder(resource)
  {
  }
 
  constexpr AudioDecoderRef(const AudioDecoder& resource) noexcept
    : AudioDecoder(resource.get())
  {
  }
 
  constexpr AudioDecoderRef(AudioDecoder&& resource) noexcept
    : AudioDecoder(std::move(resource).release())
  {
  }
 
  constexpr AudioDecoderRef(const AudioDecoderRef& other) noexcept
    : AudioDecoder(other.get())
  {
  }
 
  constexpr AudioDecoderRef(AudioDecoderRef&& other) noexcept
    : AudioDecoder(other.get())
  {
  }
 
  ~AudioDecoderRef() { release(); }
 
  AudioDecoderRef& operator=(const AudioDecoderRef& other) noexcept
  {
    release();
    AudioDecoder::operator=(AudioDecoder(other.get()));
    return *this;
  }
 
  constexpr operator AudioDecoderRaw() const noexcept { return get(); }
};
 
inline AudioDecoder CreateAudioDecoder(StringParam path,
                                       PropertiesRef props = nullptr)
{
  return AudioDecoder(std::move(path), props);
}
 
inline AudioDecoder::AudioDecoder(StringParam path, PropertiesRef props)
  : m_resource(MIX_CreateAudioDecoder(path, props))
{
}
 
inline AudioDecoder::AudioDecoder(IOStreamRef io,
                                  bool closeio,
                                  PropertiesRef props)
  : m_resource(MIX_CreateAudioDecoder_IO(io, closeio, props))
{
}
 
inline AudioDecoder CreateAudioDecoder_IO(IOStreamRef io,
                                          bool closeio = false,
                                          PropertiesRef props = nullptr)
{
  return AudioDecoder(io, closeio, props);
}
 
inline void DestroyAudioDecoder(AudioDecoderRaw audiodecoder)
{
  MIX_DestroyAudioDecoder(audiodecoder);
}
 
inline void AudioDecoder::Destroy() { DestroyAudioDecoder(release()); }
 
inline PropertiesRef GetAudioDecoderProperties(AudioDecoderRef audiodecoder)
{
  return CheckError(MIX_GetAudioDecoderProperties(audiodecoder));
}
 
inline PropertiesRef AudioDecoder::GetProperties()
{
  return SDL::GetAudioDecoderProperties(m_resource);
}
 
inline void GetAudioDecoderFormat(AudioDecoderRef audiodecoder, AudioSpec* spec)
{
  CheckError(MIX_GetAudioDecoderFormat(audiodecoder, spec));
}
 
inline void AudioDecoder::GetFormat(AudioSpec* spec)
{
  SDL::GetAudioDecoderFormat(m_resource, spec);
}
 
inline int DecodeAudio(AudioDecoderRef audiodecoder,
                       TargetBytes buffer,
                       const AudioSpec& spec)
{
  return CheckError(
    MIX_DecodeAudio(
      audiodecoder, buffer.data(), narrowS32(buffer.size_bytes()), &spec),
    -1);
}
 
inline int AudioDecoder::DecodeAudio(TargetBytes buffer, const AudioSpec& spec)
{
  return SDL::DecodeAudio(m_resource, std::move(buffer), spec);
}
 
 
} // namespace SDL
 
#endif /* defined(SDL3PP_ENABLE_MIXER) || defined(SDL3PP_DOC) */
 
#endif /* SDL3PP_MIXER_H_ */