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

using MixerRef = ResourceRef<Mixer>;
 
// Forward decl
struct Audio;

using AudioRaw = MIX_Audio*;

using AudioRef = ResourceRef<Audio>;
 
// Forward decl
struct Track;

using TrackRaw = MIX_Track*;

using TrackRef = ResourceRef<Track>;
 
// Forward decl
struct Group;

using GroupRaw = MIX_Group*;

using GroupRef = ResourceRef<Group>;
 
// Forward decl
struct AudioDecoder;

using AudioDecoderRaw = MIX_AudioDecoder*;

using AudioDecoderRef = ResourceRef<AudioDecoder>;
 
// 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)>;

struct Mixer : ResourceBase<MixerRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Mixer(MixerRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Mixer(const Mixer& other) = delete;

  constexpr Mixer(Mixer&& other) noexcept
    : Mixer(other.release())
  {
  }
 
  constexpr Mixer(const MixerRef& other) = delete;
 
  constexpr Mixer(MixerRef&& other) = delete;

  Mixer(AudioDeviceRef devid, OptionalRef<const AudioSpec> spec = std::nullopt);

  Mixer(const AudioSpec& spec);

  ~Mixer() { MIX_DestroyMixer(get()); }

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

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

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

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

struct Audio : ResourceBase<AudioRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Audio(AudioRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Audio(const Audio& other) = 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(get()); }

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

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

  void Destroy();

  PropertiesRef GetProperties();

  Sint64 GetDuration();

  void GetFormat(AudioSpec* spec);

  Sint64 MSToFrames(Milliseconds ms);

  Milliseconds FramesToMS(Sint64 frames);
};

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

struct Track : ResourceBase<TrackRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Track(TrackRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Track(const Track& other) = 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(get()); }

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

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

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

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

struct Group : ResourceBase<GroupRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Group(GroupRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Group(const Group& other) = 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(get()); }

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

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

  void Destroy();

  PropertiesRef GetProperties();

  MixerRef GetMixer();

  void SetPostMixCallback(GroupMixCallback cb, void* userdata);
};
 
#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,
                               OptionalRef<const AudioSpec> spec = std::nullopt)
{
  return Mixer(devid, spec);
}
 
inline Mixer::Mixer(AudioDeviceRef devid, OptionalRef<const AudioSpec> spec)
  : Mixer(CheckError(MIX_CreateMixerDevice(devid, spec)))
{
}
 
inline Mixer::Mixer(const AudioSpec& spec)
  : Mixer(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(get());
}

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(get(), 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(get(), io, predecode, closeio);
}
 
inline Audio::Audio(MixerRef mixer,
                    IOStreamRef io,
                    bool predecode,
                    bool closeio)
  : Audio(MIX_LoadAudio_IO(mixer, io, predecode, closeio))
{
}
 
inline Audio::Audio(MixerRef mixer, StringParam path, bool predecode)
  : Audio(MIX_LoadAudio(mixer, path, predecode))
{
}
 
inline Audio::Audio(PropertiesRef props)
  : Audio(CheckError(MIX_LoadAudioWithProperties(props)))
{
}
 
inline Audio::Audio(MixerRef mixer,
                    IOStreamRef io,
                    const AudioSpec& spec,
                    bool closeio)
  : Audio(CheckError(MIX_LoadRawAudio_IO(mixer, io, &spec, closeio)))
{
}
 
inline Audio::Audio(MixerRef mixer, SourceBytes data, const AudioSpec& spec)
  : Audio(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(get(), 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(get(), 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(get(), 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(get(), 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(get(), 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(get(), hz, amplitude, ms);
}

inline PropertiesRef GetAudioProperties(AudioRef audio)
{
  return CheckError(MIX_GetAudioProperties(audio));
}
 
inline PropertiesRef Audio::GetProperties()
{
  return SDL::GetAudioProperties(get());
}

namespace prop::Audio::Metadata {
 
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::Audio::Metadata

inline Sint64 GetAudioDuration(AudioRef audio)
{
  return MIX_GetAudioDuration(audio);
}
 
inline Sint64 Audio::GetDuration() { return SDL::GetAudioDuration(get()); }

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(get(), 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(get()); }
 
inline Track::Track(MixerRef mixer)
  : Track(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(get());
}

inline MixerRef GetTrackMixer(TrackRef track)
{
  return CheckError(MIX_GetTrackMixer(track));
}
 
inline MixerRef Track::GetMixer() { return SDL::GetTrackMixer(get()); }

inline void SetTrackAudio(TrackRef track, AudioRef audio)
{
  CheckError(MIX_SetTrackAudio(track, audio));
}
 
inline void Track::SetAudio(AudioRef audio)
{
  SDL::SetTrackAudio(get(), audio);
}

inline void SetTrackAudioStream(TrackRef track, AudioStreamRef stream)
{
  CheckError(MIX_SetTrackAudioStream(track, stream));
}
 
inline void Track::SetAudioStream(AudioStreamRef stream)
{
  SDL::SetTrackAudioStream(get(), 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(get(), 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(get(), io, spec, closeio);
}

inline void TagTrack(TrackRef track, StringParam tag)
{
  CheckError(MIX_TagTrack(track, tag));
}
 
inline void Track::Tag(StringParam tag)
{
  SDL::TagTrack(get(), std::move(tag));
}

inline void UntagTrack(TrackRef track, StringParam tag)
{
  MIX_UntagTrack(track, tag);
}
 
inline void Track::Untag(StringParam tag)
{
  SDL::UntagTrack(get(), 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(get()); }

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(get(), std::move(tag));
}

inline void SetTrackPlaybackPosition(TrackRef track, Sint64 frames)
{
  CheckError(MIX_SetTrackPlaybackPosition(track, frames));
}
 
inline void Track::SetPlaybackPosition(Sint64 frames)
{
  SDL::SetTrackPlaybackPosition(get(), frames);
}

inline Sint64 GetTrackPlaybackPosition(TrackRef track)
{
  return MIX_GetTrackPlaybackPosition(track);
}
 
inline Sint64 Track::GetPlaybackPosition()
{
  return SDL::GetTrackPlaybackPosition(get());
}

inline Sint64 GetTrackFadeFrames(TrackRef track)
{
  return MIX_GetTrackFadeFrames(track);
}
 
inline Sint64 Track::GetFadeFrames() { return SDL::GetTrackFadeFrames(get()); }

inline int GetTrackLoops(TrackRef track) { return MIX_GetTrackLoops(track); }
 
inline int Track::GetLoops() { return SDL::GetTrackLoops(get()); }

inline void SetTrackLoops(TrackRef track, int num_loops)
{
  CheckError(MIX_SetTrackLoops(track, num_loops));
}
 
inline void Track::SetLoops(int num_loops)
{
  SDL::SetTrackLoops(get(), num_loops);
}

inline AudioRef GetTrackAudio(TrackRef track)
{
  return MIX_GetTrackAudio(track);
}
 
inline AudioRef Track::GetAudio() { return SDL::GetTrackAudio(get()); }

inline AudioStreamRef GetTrackAudioStream(TrackRef track)
{
  return MIX_GetTrackAudioStream(track);
}
 
inline AudioStreamRef Track::GetAudioStream()
{
  return SDL::GetTrackAudioStream(get());
}

inline Sint64 GetTrackRemaining(TrackRef track)
{
  return MIX_GetTrackRemaining(track);
}
 
inline Sint64 Track::GetRemaining() { return SDL::GetTrackRemaining(get()); }

inline Sint64 TrackMSToFrames(TrackRef track, Milliseconds ms)
{
  return MIX_TrackMSToFrames(track, ms.count());
}
 
inline Sint64 Track::MSToFrames(Milliseconds ms)
{
  return SDL::TrackMSToFrames(get(), ms);
}

inline Milliseconds TrackFramesToMS(TrackRef track, Sint64 frames)
{
  return Milliseconds(MIX_TrackFramesToMS(track, frames));
}
 
inline Milliseconds Track::FramesToMS(Sint64 frames)
{
  return SDL::TrackFramesToMS(get(), frames);
}

inline Sint64 AudioMSToFrames(AudioRef audio, Milliseconds ms)
{
  return MIX_AudioMSToFrames(audio, ms.count());
}
 
inline Sint64 Audio::MSToFrames(Milliseconds ms)
{
  return SDL::AudioMSToFrames(get(), ms);
}

inline Milliseconds AudioFramesToMS(AudioRef audio, Sint64 frames)
{
  return Milliseconds(MIX_AudioFramesToMS(audio, frames));
}
 
inline Milliseconds Audio::FramesToMS(Sint64 frames)
{
  return SDL::AudioFramesToMS(get(), 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(get(), 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(get(), 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(get(), 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(get(), 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(get(), 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(get(), std::move(tag), fade_out_ms);
}

inline bool PauseTrack(TrackRef track) { return MIX_PauseTrack(track); }
 
inline bool Track::Pause() { return SDL::PauseTrack(get()); }

inline void PauseAllTracks(MixerRef mixer)
{
  CheckError(MIX_PauseAllTracks(mixer));
}
 
inline void Mixer::PauseAllTracks() { SDL::PauseAllTracks(get()); }

inline void PauseTag(MixerRef mixer, StringParam tag)
{
  CheckError(MIX_PauseTag(mixer, tag));
}
 
inline void Mixer::PauseTag(StringParam tag)
{
  SDL::PauseTag(get(), std::move(tag));
}

inline bool ResumeTrack(TrackRef track) { return MIX_ResumeTrack(track); }
 
inline bool Track::Resume() { return SDL::ResumeTrack(get()); }

inline void ResumeAllTracks(MixerRef mixer)
{
  CheckError(MIX_ResumeAllTracks(mixer));
}
 
inline void Mixer::ResumeAllTracks() { SDL::ResumeAllTracks(get()); }

inline void ResumeTag(MixerRef mixer, StringParam tag)
{
  CheckError(MIX_ResumeTag(mixer, tag));
}
 
inline void Mixer::ResumeTag(StringParam tag)
{
  SDL::ResumeTag(get(), std::move(tag));
}

inline bool TrackPlaying(TrackRef track) { return MIX_TrackPlaying(track); }
 
inline bool Track::Playing() { return SDL::TrackPlaying(get()); }

inline bool TrackPaused(TrackRef track) { return MIX_TrackPaused(track); }
 
inline bool Track::Paused() { return SDL::TrackPaused(get()); }

inline void SetMixerGain(MixerRef mixer, float gain)
{
  CheckError(MIX_SetMixerGain(mixer, gain));
}
 
inline void Mixer::SetGain(float gain) { SDL::SetMixerGain(get(), gain); }

inline float GetMixerGain(MixerRef mixer) { return MIX_GetMixerGain(mixer); }
 
inline float Mixer::GetGain() { return SDL::GetMixerGain(get()); }

inline void SetTrackGain(TrackRef track, float gain)
{
  CheckError(MIX_SetTrackGain(track, gain));
}
 
inline void Track::SetGain(float gain) { SDL::SetTrackGain(get(), gain); }

inline float GetTrackGain(TrackRef track) { return MIX_GetTrackGain(track); }
 
inline float Track::GetGain() { return SDL::GetTrackGain(get()); }

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(get(), std::move(tag), gain);
}

inline void SetMixerFrequencyRatio(MixerRef mixer, float ratio)
{
  CheckError(MIX_SetMixerFrequencyRatio(mixer, ratio));
}
 
inline void Mixer::SetFrequencyRatio(float ratio)
{
  SDL::SetMixerFrequencyRatio(get(), ratio);
}

inline float GetMixerFrequencyRatio(MixerRef mixer)
{
  return MIX_GetMixerFrequencyRatio(mixer);
}
 
inline float Mixer::GetFrequencyRatio()
{
  return SDL::GetMixerFrequencyRatio(get());
}

inline void SetTrackFrequencyRatio(TrackRef track, float ratio)
{
  CheckError(MIX_SetTrackFrequencyRatio(track, ratio));
}
 
inline void Track::SetFrequencyRatio(float ratio)
{
  SDL::SetTrackFrequencyRatio(get(), ratio);
}

inline float GetTrackFrequencyRatio(TrackRef track)
{
  return MIX_GetTrackFrequencyRatio(track);
}
 
inline float Track::GetFrequencyRatio()
{
  return SDL::GetTrackFrequencyRatio(get());
}

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

inline void SetTrackStereo(TrackRef track, const StereoGains& gains)
{
  CheckError(MIX_SetTrackStereo(track, &gains));
}
 
inline void Track::SetStereo(const StereoGains& gains)
{
  SDL::SetTrackStereo(get(), gains);
}

inline void SetTrack3DPosition(TrackRef track, const Point3D& position)
{
  CheckError(MIX_SetTrack3DPosition(track, &position));
}
 
inline void Track::Set3DPosition(const Point3D& position)
{
  SDL::SetTrack3DPosition(get(), position);
}

inline Point3D GetTrack3DPosition(TrackRef track)
{
  Point3D position;
  CheckError(MIX_GetTrack3DPosition(track, &position));
  return position;
}
 
inline Point3D Track::Get3DPosition() { return SDL::GetTrack3DPosition(get()); }

inline Group CreateGroup(MixerRef mixer) { return Group(mixer); }
 
inline GroupRef Mixer::CreateGroup() { return Group(get()); }
 
inline Group::Group(MixerRef mixer)
  : Group(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(get());
}

inline MixerRef GetGroupMixer(GroupRef group)
{
  return CheckError(MIX_GetGroupMixer(group));
}
 
inline MixerRef Group::GetMixer() { return SDL::GetGroupMixer(get()); }

inline void SetTrackGroup(TrackRef track, GroupRef group)
{
  CheckError(MIX_SetTrackGroup(track, group));
}
 
inline void Track::SetGroup(GroupRef group)
{
  SDL::SetTrackGroup(get(), 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(get(), cb, userdata);
}
 
inline void Track::SetStoppedCallback(TrackStoppedCB cb)
{
  SDL::SetTrackStoppedCallback(get(), 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(get(), cb, userdata);
}
 
inline void Track::SetRawCallback(TrackMixCB cb)
{
  SDL::SetTrackRawCallback(get(), 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(get(), cb, userdata);
}
 
inline void Track::SetCookedCallback(TrackMixCB cb)
{
  SDL::SetTrackCookedCallback(get(), 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(get(), 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(get(), cb, userdata);
}
 
inline void Mixer::SetPostMixCallback(PostMixCB cb)
{
  SDL::SetPostMixCallback(get(), 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(get(), std::move(buffer));
}

struct AudioDecoder : ResourceBase<AudioDecoderRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit AudioDecoder(AudioDecoderRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr AudioDecoder(const AudioDecoder& other) = 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(get()); }

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

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

  void Destroy();

  PropertiesRef GetProperties();

  void GetFormat(AudioSpec* spec);

  int DecodeAudio(TargetBytes buffer, const AudioSpec& spec);
};

inline AudioDecoder CreateAudioDecoder(StringParam path,
                                       PropertiesRef props = nullptr)
{
  return AudioDecoder(std::move(path), props);
}
 
inline AudioDecoder::AudioDecoder(StringParam path, PropertiesRef props)
  : AudioDecoder(MIX_CreateAudioDecoder(path, props))
{
}
 
inline AudioDecoder::AudioDecoder(IOStreamRef io,
                                  bool closeio,
                                  PropertiesRef props)
  : AudioDecoder(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(get());
}

inline void GetAudioDecoderFormat(AudioDecoderRef audiodecoder, AudioSpec* spec)
{
  CheckError(MIX_GetAudioDecoderFormat(audiodecoder, spec));
}
 
inline void AudioDecoder::GetFormat(AudioSpec* spec)
{
  SDL::GetAudioDecoderFormat(get(), 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(get(), std::move(buffer), spec);
}

 
} // namespace SDL
 
#endif /* defined(SDL3PP_ENABLE_MIXER) || defined(SDL3PP_DOC) */
 
#endif /* SDL3PP_MIXER_H_ */