mitiru::audio

Audio subsystem: mixer, streaming engine, sound buffers, audio manifest loaders, and the MML editor model.

Name	Kind	Items
IAudioEffect	class	7
ReverbEffect	class	4
ChorusEffect	class	4
DelayEffect	class	4
AudioEffectChain	class	5
IAudioEngine	class	7
SoundCategory	enum	3
SeLimiterMode	enum	3
ChannelState	enum	5
Channel	struct	8
AudioMixer	class	23
AudioOutputBackend	enum	6
AudioFormat	struct	3
IAudioStream	class	9
WavAudioStream	class	15
RawPcmAudioStream	class	14
AudioOutputParams	struct	3
IAudioOutput	class	10
MidiNote	struct	5
MidiTrack	struct	3
MidiFile	struct	4
MidiToMml	class	3
AudioFormat	enum	5
MiniaudioBridge	class	20
MiniaudioEngine	class	13
MitiruAudioPlayer	class	12
Pitch	enum	12
Octave	enum	4
Duration	enum	5
Accidental	enum	3
EditorCommandType	enum	6
MmlNote	struct	7
MmlTrack	struct	7
TimeSignature	struct	2
MmlComposition	struct	5
NoteSelection	struct	5
EditorCommand	struct	10
MmlEditorModel	class	34
MusicGenre	enum	9
PhraseTemplate	struct	4
MmlPhraseGenerator	class	5
NullAudioEngine	class	6
NullAudioOutput	class	18
IAudioDecoder	class	10
AdpcmDecoder	class	15
OggVorbisDecoder	class	13
DecoderStreamAdapter	class	13
PulseSimpleHandle	class	10
AudioRingBuffer	class	6
PulseAudioOutput	class	15
RingBuffer	class	15
AdsrParams	struct	4
SineSynth	class	28
SoundState	struct	3
SoftAudioEngine	class	11
AttenuationModel	enum	4
AudioVec3	struct	5
SpatialSourceConfig	struct	5
SpatialResult	struct	3
SpatialAudio	class	4
StreamState	enum	3
StreamingAudioEngine	class	28
WebAudioEngine	class	8
AudioBackend	enum	6
FmodAudioEngine	class	19
FmodAudioEngine	class	9
FmodStudioEngine	class	15
FmodStudioEngine	class	8

class IAudioEffect 7

virtual ~IAudioEffect() = default

virtual void process(float* samples, int numSamples, int sampleRate) = 0

[[nodiscard]] virtual const char* name() const noexcept = 0

virtual void setWetDry(float wet)

[[nodiscard]] float wetDry() const noexcept

void setEnabled(bool e) noexcept

[[nodiscard]] bool isEnabled() const noexcept

class ReverbEffect : public IAudioEffect 4

[[nodiscard]] const char* name() const noexcept override

void setDecay(float d) noexcept

void setRoomSize(float s) noexcept

void process(float* samples, int numSamples, [[maybe_unused]] int sampleRate) override

class ChorusEffect : public IAudioEffect 4

[[nodiscard]] const char* name() const noexcept override

void setRate(float hz) noexcept

void setDepth(float ms) noexcept

void process(float* samples, int numSamples, int sampleRate) override

class DelayEffect : public IAudioEffect 4

[[nodiscard]] const char* name() const noexcept override

void setDelayMs(float ms) noexcept

void setFeedback(float fb) noexcept

void process(float* samples, int numSamples, int sampleRate) override

class AudioEffectChain 5

void addEffect(std::unique_ptr<IAudioEffect> effect)

void process(float* samples, int numSamples, int sampleRate)

[[nodiscard]] size_t effectCount() const noexcept

[[nodiscard]] IAudioEffect* getEffect(size_t idx)

static AudioEffectChain createDefault()

class IAudioEngine 7

virtual ~IAudioEngine() = default

virtual void playSound(std::string_view id) = 0

virtual void stopSound(std::string_view id) = 0

virtual void playMusic(std::string_view id) = 0

virtual void stopMusic() = 0

virtual void setVolume(float volume) = 0

[[nodiscard]] virtual bool isPlaying(std::string_view id) const = 0

enum SoundCategory : uint8_t 3

Bgm = 0

Se

Voice

enum SeLimiterMode : uint8_t 3

None = 0

EqualPower

Linear

enum ChannelState : uint8_t 5

Idle = 0

Playing

Paused

FadingIn

FadingOut

struct Channel 8

int handle = -1

std::string soundId

SoundCategory category = SoundCategory::Se

ChannelState state = ChannelState::Idle

float volume = 1.0f

float fadeTarget = 1.0f

float fadeSpeed = 0.0f

bool looping = false

class AudioMixer 23

AudioMixer() noexcept

int play(std::string_view soundId, SoundCategory category, bool loop = false, float volume = 1.0f)

void stop(int handle)

void stopByCategory(SoundCategory category)

void stopAll()

void pause(int handle)

void resume(int handle)

void fadeIn(int handle, float targetVolume, float durationSeconds)

void fadeOut(int handle, float durationSeconds)

int crossfadeBgm(std::string_view newSoundId, float durationSeconds, float newVolume = 1.0f)

void update(float deltaTime)

void setCategoryVolume(SoundCategory category, float volume)

[[nodiscard]] float categoryVolume(SoundCategory category) const

void setMasterVolume(float volume)

[[nodiscard]] float masterVolume() const

[[nodiscard]] float effectiveVolume(int handle) const

void setSeLimiterMode(SeLimiterMode mode)

[[nodiscard]] SeLimiterMode seLimiterMode() const

[[nodiscard]] int activeCategoryChannelCount(SoundCategory category) const

[[nodiscard]] bool isPlaying(int handle) const

[[nodiscard]] ChannelState channelState(int handle) const

[[nodiscard]] int activeChannelCount() const

void setOnChannelStopped(std::function<void(int)> callback)

enum AudioOutputBackend 6

Auto

PulseAudio

Null

[[nodiscard]] inline std::unique_ptr<IAudioOutput> createAudioOutput( AudioOutputBackend backend = AudioOutputBackend::Auto)

[[nodiscard]] inline const char* availableAudioBackendName() noexcept

[[nodiscard]] inline constexpr bool hasPulseAudioSupport() noexcept

struct AudioFormat 3

int sampleRate = 44100

int channels = 2

int bitsPerSample = 16

class IAudioStream 9

virtual ~IAudioStream() = default

virtual bool open() = 0

virtual void close() = 0

virtual std::size_t read(float* buffer, std::size_t frames) = 0

virtual bool seek(std::size_t frameOffset) = 0

[[nodiscard]] virtual AudioFormat format() const noexcept = 0

[[nodiscard]] virtual std::size_t totalFrames() const noexcept = 0

[[nodiscard]] virtual bool isEof() const noexcept = 0

[[nodiscard]] virtual bool isOpen() const noexcept = 0

class WavAudioStream : public IAudioStream 15

explicit WavAudioStream(std::string_view filePath)

~WavAudioStream() override

WavAudioStream(const WavAudioStream&) = delete

WavAudioStream& operator=(const WavAudioStream&) = delete

WavAudioStream(WavAudioStream&&) noexcept = default

WavAudioStream& operator=(WavAudioStream&&) noexcept = default

bool open() override

void close() override

std::size_t read(float* buffer, std::size_t frames) override

bool seek(std::size_t frameOffset) override

[[nodiscard]] AudioFormat format() const noexcept override

[[nodiscard]] std::size_t totalFrames() const noexcept override

[[nodiscard]] bool isEof() const noexcept override

[[nodiscard]] bool isOpen() const noexcept override

[[nodiscard]] std::size_t currentFrame() const noexcept

class RawPcmAudioStream : public IAudioStream 14

RawPcmAudioStream(std::string_view filePath, AudioFormat fmt)

~RawPcmAudioStream() override

RawPcmAudioStream(const RawPcmAudioStream&) = delete

RawPcmAudioStream& operator=(const RawPcmAudioStream&) = delete

RawPcmAudioStream(RawPcmAudioStream&&) noexcept = default

RawPcmAudioStream& operator=(RawPcmAudioStream&&) noexcept = default

bool open() override

void close() override

std::size_t read(float* buffer, std::size_t frames) override

bool seek(std::size_t frameOffset) override

[[nodiscard]] AudioFormat format() const noexcept override

[[nodiscard]] std::size_t totalFrames() const noexcept override

[[nodiscard]] bool isEof() const noexcept override

[[nodiscard]] bool isOpen() const noexcept override

struct AudioOutputParams 3

int sampleRate = 44100

int channels = 2

int bufferSize = 4096

class IAudioOutput 10

virtual ~IAudioOutput() = default

virtual bool initialize(int sampleRate, int channels, int bufferSize) = 0

virtual bool write(const float* samples, std::size_t count) = 0

[[nodiscard]] virtual bool isPlaying() const = 0

virtual void shutdown() = 0

[[nodiscard]] virtual bool isInitialized() const = 0

[[nodiscard]] virtual int sampleRate() const = 0

[[nodiscard]] virtual int channels() const = 0

[[nodiscard]] virtual int bufferSize() const = 0

[[nodiscard]] virtual const char* backendName() const = 0

struct MidiNote 5

uint32_t tick = 0

uint32_t duration = 0

uint8_t channel = 0

uint8_t note = 60

uint8_t velocity = 100

struct MidiTrack 3

std::string name

std::vector<MidiNote> notes

uint8_t program = 0

struct MidiFile 4

uint16_t format = 1

uint16_t ticksPerBeat = 480

int tempo = 120

std::vector<MidiTrack> tracks

class MidiToMml 3

[[nodiscard]] bool loadSmf(const std::string& path)

[[nodiscard]] std::string toMml(int trackIndex = 0) const

[[nodiscard]] const MidiFile& midi() const noexcept

enum AudioFormat : std::uint8_t 5

Wav

Mp3

Flac

Ogg

Unknown

class MiniaudioBridge 20

explicit MiniaudioBridge(MiniaudioEngine& engine) noexcept

MiniaudioBridge(const MiniaudioBridge&) = delete

MiniaudioBridge& operator=(const MiniaudioBridge&) = delete

MiniaudioBridge(MiniaudioBridge&&) = delete

MiniaudioBridge& operator=(MiniaudioBridge&&) = delete

void setBasePath(std::string_view path)

[[nodiscard]] const std::string& basePath() const noexcept

void connectToDynamicBGM(vn::DynamicBGMController& bgm)

void connectToAudioMixer(AudioMixer& mixer)

void playVoice(std::string_view path)

void playSE(std::string_view path)

void playBGM(std::string_view path, bool loop = true)

void stopAll()

[[nodiscard]] static AudioFormat detectFormat(std::string_view path) noexcept

[[nodiscard]] static bool isFormatSupported(AudioFormat format) noexcept

[[nodiscard]] static bool isFileSupported(std::string_view path) noexcept

[[nodiscard]] static constexpr std::array<std::string_view, 4> supportedExtensions() noexcept

[[nodiscard]] MiniaudioEngine& engine() noexcept

[[nodiscard]] const MiniaudioEngine& engine() const noexcept

[[nodiscard]] bool isReady() const noexcept

class MiniaudioEngine 13

MiniaudioEngine()

~MiniaudioEngine()

MiniaudioEngine(const MiniaudioEngine&) = delete

MiniaudioEngine& operator=(const MiniaudioEngine&) = delete

MiniaudioEngine(MiniaudioEngine&& other) noexcept

MiniaudioEngine& operator=(MiniaudioEngine&& other) noexcept

[[nodiscard]] bool isInitialized() const noexcept

void playFile(const std::string& path)

void playFile(std::string_view path)

void setMasterVolume(float volume)

[[nodiscard]] float getMasterVolume() const

void stopAll()

void resume()

class MitiruAudioPlayer : public sgc::IAudioPlayer 12

explicit MitiruAudioPlayer(IAudioEngine* engine, AudioMixer* mixer = nullptr) noexcept

void playBgm(std::string_view path, float volume) override

void stopBgm(float fadeOutSeconds) override

void pauseBgm() override

void resumeBgm() override

void setBgmVolume(float volume) override

[[nodiscard]] bool isBgmPlaying() const override

int playSe(std::string_view path, float volume) override

void stopSe(int handle) override

void stopAllSe() override

void setSeVolume(float volume) override

void setMasterVolume(float volume) override

enum Pitch : uint8_t 12

C = 0

Cs

D

Ds

E

F

Fs

G

Gs

A

As

B

enum Octave : uint8_t 4

O4 = 4

O5 = 5

O6 = 6

O7 = 7

enum Duration : uint8_t 5

Whole = 1

Half = 2

Quarter = 4

Eighth = 8

Sixteenth = 16

enum Accidental : uint8_t 3

Natural = 0

Sharp

Flat

enum EditorCommandType : uint8_t 6

AddNote

RemoveNote

InsertNote

SetTempo

SetInstrument

PasteNotes

struct MmlNote 7

Pitch pitch = Pitch::C

Octave octave = Octave::O4

Duration duration = Duration::Quarter

Accidental accidental = Accidental::Natural

bool dotted = false

bool rest = false

[[nodiscard]] float beats() const noexcept

struct MmlTrack 7

std::string name

int channel = 0

std::vector<MmlNote> notes

std::string instrument = "Piano"

int volume = 100

int tempo = 120

[[nodiscard]] float totalBeats() const noexcept

struct TimeSignature 2

int numerator = 4

int denominator = 4

struct MmlComposition 5

std::vector<MmlTrack> tracks

std::string title

std::string author

int tempo = 120

TimeSignature timeSignature

struct NoteSelection 5

int trackIndex = -1

int startIndex = 0

int endIndex = 0

[[nodiscard]] bool valid() const noexcept

[[nodiscard]] int count() const noexcept

struct EditorCommand 10

EditorCommandType type = EditorCommandType::AddNote

int trackIndex = 0

int noteIndex = 0

MmlNote note

MmlNote previousNote

std::vector<MmlNote> notesBatch

int previousTempo = 120

int newTempo = 120

std::string previousInstrument

std::string newInstrument

class MmlEditorModel 34

MmlEditorModel() = default

void addTrack(std::string_view name, int channel, std::string_view instrument = "Piano")

void removeTrack(int trackIndex)

[[nodiscard]] int trackCount() const noexcept

[[nodiscard]] const MmlTrack& track(int trackIndex) const

void addNote(int trackIndex, const MmlNote& note)

void removeNote(int trackIndex, int noteIndex)

void insertNote(int trackIndex, int noteIndex, const MmlNote& note)

void setTempo(int bpm)

void setInstrument(int trackIndex, std::string_view instrument)

void setTimeSignature(int numerator, int denominator)

void setTitle(std::string_view title)

void setAuthor(std::string_view author)

[[nodiscard]] std::string toMmlString() const

void fromMmlString(std::string_view mml)

[[nodiscard]] std::string toJson() const

void fromJson(std::string_view json)

[[nodiscard]] float getDuration() const noexcept

bool undo()

bool redo()

[[nodiscard]] bool canUndo() const noexcept

[[nodiscard]] bool canRedo() const noexcept

void selectNotes(int trackIndex, int startIndex, int endIndex)

void clearSelection() noexcept

[[nodiscard]] const NoteSelection& selectedNotes() const noexcept

void copy()

void cut()

void paste(int trackIndex, int noteIndex)

[[nodiscard]] bool hasClipboardContent() const noexcept

void setPlaybackCursor(float position) noexcept

[[nodiscard]] float playbackCursor() const noexcept

void advancePlaybackCursor(float deltaTime) noexcept

void resetPlaybackCursor() noexcept

[[nodiscard]] const MmlComposition& composition() const noexcept

enum MusicGenre : uint8_t 9

RPGField

RPGBattle

RPGBoss

RPGTown

Puzzle

Action

Horror

Menu

Custom

struct PhraseTemplate 4

std::string name

std::string mml

MusicGenre genre = MusicGenre::Custom

int tempo = 120

class MmlPhraseGenerator 5

MmlPhraseGenerator()

[[nodiscard]] std::string generate(MusicGenre genre, int measures = 4, uint32_t seed = 0)

[[nodiscard]] std::string generateMelody( const std::vector<std::string>& chords, int tempo = 120, uint32_t seed = 0)

void addPhrase(PhraseTemplate phrase)

[[nodiscard]] size_t phraseCount() const noexcept

class NullAudioEngine : public IAudioEngine 6

void playSound(std::string_view id) override

void stopSound(std::string_view id) override

void playMusic(std::string_view id) override

void stopMusic() override

void setVolume(float volume) override

[[nodiscard]] bool isPlaying(std::string_view id) const override

class NullAudioOutput : public IAudioOutput 18

NullAudioOutput() noexcept = default

~NullAudioOutput() override

NullAudioOutput(const NullAudioOutput&) = delete

NullAudioOutput& operator=(const NullAudioOutput&) = delete

NullAudioOutput(NullAudioOutput&&) noexcept = default

NullAudioOutput& operator=(NullAudioOutput&&) noexcept = default

bool initialize(int sr, int ch, int bs) override

bool write(const float* samples, std::size_t count) override

[[nodiscard]] bool isPlaying() const override

void shutdown() override

[[nodiscard]] bool isInitialized() const override

[[nodiscard]] int sampleRate() const override

[[nodiscard]] int channels() const override

[[nodiscard]] int bufferSize() const override

[[nodiscard]] const char* backendName() const override

[[nodiscard]] std::size_t totalSamplesWritten() const noexcept

[[nodiscard]] std::size_t writeCallCount() const noexcept

void resetCounters() noexcept

class IAudioDecoder 10

virtual ~IAudioDecoder() = default

virtual bool open(std::string_view filePath) = 0

virtual void close() = 0

virtual std::size_t read(float* buffer, std::size_t frames) = 0

virtual bool seek(std::size_t frameOffset) = 0

[[nodiscard]] virtual AudioFormat format() const noexcept = 0

[[nodiscard]] virtual std::size_t totalFrames() const noexcept = 0

[[nodiscard]] virtual bool isEof() const noexcept = 0

[[nodiscard]] virtual bool isOpen() const noexcept = 0

[[nodiscard]] virtual const char* codecName() const noexcept = 0

class AdpcmDecoder : public IAudioDecoder 15

~AdpcmDecoder() override

AdpcmDecoder(const AdpcmDecoder&) = delete

AdpcmDecoder& operator=(const AdpcmDecoder&) = delete

AdpcmDecoder() = default

AdpcmDecoder(AdpcmDecoder&&) noexcept = default

AdpcmDecoder& operator=(AdpcmDecoder&&) noexcept = default

bool open(std::string_view filePath) override

void close() override

std::size_t read(float* buffer, std::size_t frames) override

bool seek(std::size_t frameOffset) override

[[nodiscard]] AudioFormat format() const noexcept override

[[nodiscard]] std::size_t totalFrames() const noexcept override

[[nodiscard]] bool isEof() const noexcept override

[[nodiscard]] bool isOpen() const noexcept override

[[nodiscard]] const char* codecName() const noexcept override

class OggVorbisDecoder : public IAudioDecoder 13

OggVorbisDecoder() = default

~OggVorbisDecoder() override

OggVorbisDecoder(const OggVorbisDecoder&) = delete

OggVorbisDecoder& operator=(const OggVorbisDecoder&) = delete

bool open(std::string_view filePath) override

void close() override

std::size_t read(float* buffer, std::size_t frames) override

bool seek(std::size_t frameOffset) override

[[nodiscard]] AudioFormat format() const noexcept override

[[nodiscard]] std::size_t totalFrames() const noexcept override

[[nodiscard]] bool isEof() const noexcept override

[[nodiscard]] bool isOpen() const noexcept override

[[nodiscard]] const char* codecName() const noexcept override

class DecoderStreamAdapter : public IAudioStream 13

explicit DecoderStreamAdapter(std::unique_ptr<IAudioDecoder> decoder)

DecoderStreamAdapter(const DecoderStreamAdapter&) = delete

DecoderStreamAdapter& operator=(const DecoderStreamAdapter&) = delete

DecoderStreamAdapter(DecoderStreamAdapter&&) noexcept = default

DecoderStreamAdapter& operator=(DecoderStreamAdapter&&) noexcept = default

bool open() override

void close() override

std::size_t read(float* buffer, std::size_t frames) override

bool seek(std::size_t frameOffset) override

[[nodiscard]] AudioFormat format() const noexcept override

[[nodiscard]] std::size_t totalFrames() const noexcept override

[[nodiscard]] bool isEof() const noexcept override

[[nodiscard]] bool isOpen() const noexcept override

class PulseSimpleHandle 10

PulseSimpleHandle() noexcept = default

explicit PulseSimpleHandle(pa_simple* handle) noexcept

~PulseSimpleHandle()

PulseSimpleHandle(const PulseSimpleHandle&) = delete

PulseSimpleHandle& operator=(const PulseSimpleHandle&) = delete

PulseSimpleHandle(PulseSimpleHandle&& other) noexcept

PulseSimpleHandle& operator=(PulseSimpleHandle&& other) noexcept

void reset() noexcept

[[nodiscard]] pa_simple* get() const noexcept

[[nodiscard]] explicit operator bool() const noexcept

class AudioRingBuffer 6

explicit AudioRingBuffer(std::size_t capacity)

std::size_t write(const float* data, std::size_t count)

std::size_t read(float* data, std::size_t count)

[[nodiscard]] std::size_t size() const

[[nodiscard]] std::size_t capacity() const noexcept

void clear()

class PulseAudioOutput : public IAudioOutput 15

PulseAudioOutput() noexcept = default

~PulseAudioOutput() override

PulseAudioOutput(const PulseAudioOutput&) = delete

PulseAudioOutput& operator=(const PulseAudioOutput&) = delete

PulseAudioOutput(PulseAudioOutput&&) = delete

PulseAudioOutput& operator=(PulseAudioOutput&&) = delete

bool initialize(int sr, int ch, int bs) override

bool write(const float* samples, std::size_t count) override

[[nodiscard]] bool isPlaying() const override

void shutdown() override

[[nodiscard]] bool isInitialized() const override

[[nodiscard]] int sampleRate() const override

[[nodiscard]] int channels() const override

[[nodiscard]] int bufferSize() const override

[[nodiscard]] const char* backendName() const override

class RingBuffer 15

explicit RingBuffer(std::size_t capacity)

RingBuffer(const RingBuffer&) = delete

RingBuffer& operator=(const RingBuffer&) = delete

RingBuffer(RingBuffer&&) noexcept = default

RingBuffer& operator=(RingBuffer&&) noexcept = default

~RingBuffer() = default

std::size_t write(const T* data, std::size_t count) noexcept

std::size_t read(T* data, std::size_t count) noexcept

[[nodiscard]] std::size_t availableRead() const noexcept

[[nodiscard]] std::size_t availableWrite() const noexcept

[[nodiscard]] std::size_t capacity() const noexcept

[[nodiscard]] bool empty() const noexcept

[[nodiscard]] bool full() const noexcept

void reset() noexcept

using VoiceHandle = int;

struct AdsrParams 4

float attackSec = 0.01f

float decaySec = 0.1f

float sustainLvl = 0.7f

float releaseSec = 0.2f

class SineSynth : public IAudioStream 28

explicit SineSynth(std::size_t voiceCount, std::uint32_t sampleRate, std::uint16_t channels = 1) noexcept

SineSynth() noexcept = default

SineSynth(const SineSynth&) = delete

SineSynth& operator=(const SineSynth&) = delete

SineSynth(SineSynth&&) = delete

SineSynth& operator=(SineSynth&&) = delete

void setMaxVoices(int voices) noexcept

[[nodiscard]] int maxVoices() const noexcept

void setAdsr(const AdsrParams& params) noexcept

[[nodiscard]] AdsrParams adsr() const noexcept

void setGain(float gain) noexcept

[[nodiscard]] float gain() const noexcept

VoiceHandle noteOn(int midiNote, float velocity) noexcept

void noteOff(VoiceHandle handle) noexcept

void allNotesOff() noexcept

[[nodiscard]] int activeVoiceCount() const noexcept

[[nodiscard]] bool isActive(VoiceHandle handle) const noexcept

void render(float* buffer, std::size_t frames, int sampleRate) noexcept

bool open() override

void close() override

std::size_t read(float* buffer, std::size_t frames) override

bool seek(std::size_t ) override

[[nodiscard]] AudioFormat format() const noexcept override

[[nodiscard]] std::size_t totalFrames() const noexcept override

[[nodiscard]] bool isEof() const noexcept override

[[nodiscard]] bool isOpen() const noexcept override

void setEnvelope(float attackSec, float decaySec, float sustainLevel, float releaseSec) noexcept

void setMasterGain(float g) noexcept

struct SoundState 3

std::string id

float volume = 1.0f

bool looping = false

class SoftAudioEngine : public IAudioEngine 11

void playSound(std::string_view id) override

void stopSound(std::string_view id) override

void playMusic(std::string_view id) override

void stopMusic() override

void setVolume(float volume) override

[[nodiscard]] bool isPlaying(std::string_view id) const override

[[nodiscard]] size_t playingSoundCount() const noexcept

[[nodiscard]] const std::string& currentMusic() const noexcept

[[nodiscard]] bool isMusicPlaying() const noexcept

[[nodiscard]] float masterVolume() const noexcept

void stopAll()

enum AttenuationModel : uint8_t 4

None

InverseDistance

LinearDistance

ExponentialDistance

struct AudioVec3 5

float x = 0.0f

float y = 0.0f

float z = 0.0f

[[nodiscard]] float distanceTo(const AudioVec3& other) const noexcept

[[nodiscard]] AudioVec3 normalized() const noexcept

struct SpatialSourceConfig 5

float minDistance = 1.0f

float maxDistance = 100.0f

float rolloffFactor = 1.0f

float dopplerFactor = 0.0f

AttenuationModel attenuation = AttenuationModel::InverseDistance

struct SpatialResult 3

float volume = 1.0f

float pan = 0.0f

float doppler = 1.0f

class SpatialAudio 4

void setListener(const AudioListener& listener) noexcept

[[nodiscard]] const AudioListener& listener() const noexcept

[[nodiscard]] SpatialResult calculate( const AudioVec3& sourcePos, const SpatialSourceConfig& config = {}) const noexcept

void updateFromCamera(const float pos[3], const float fwd[3], const float up[3]) noexcept

enum StreamState : uint8_t 3

Stopped = 0

Playing

Paused

class StreamingAudioEngine 28

explicit StreamingAudioEngine( std::unique_ptr<IAudioOutput> output = nullptr, std::size_t ringBufferFrames = DEFAULT_RING_BUFFER_FRAMES)

~StreamingAudioEngine()

StreamingAudioEngine(const StreamingAudioEngine&) = delete

StreamingAudioEngine& operator=(const StreamingAudioEngine&) = delete

StreamingAudioEngine(StreamingAudioEngine&&) = delete

StreamingAudioEngine& operator=(StreamingAudioEngine&&) = delete

bool play(std::unique_ptr<IAudioStream> stream, bool loop = false)

void pause() noexcept

void resume() noexcept

void stop()

void seek(std::size_t frameOffset) noexcept

void update()

void setVolume(float volume) noexcept

[[nodiscard]] float volume() const noexcept

[[nodiscard]] StreamState state() const noexcept

[[nodiscard]] bool isPlaying() const noexcept

[[nodiscard]] bool isPaused() const noexcept

[[nodiscard]] AudioFormat format() const noexcept

[[nodiscard]] std::size_t bufferedSamples() const noexcept

void setLooping(bool loop) noexcept

[[nodiscard]] bool isLooping() const noexcept

void setOutput(std::unique_ptr<IAudioOutput> output)

#pragma once #include <string> #include <string_view> #include <unordered_map> #include <mitiru/audio/AudioEngine.hpp> #ifdef _WIN32 #ifndef NOMINMAX #define NOMINMAX #endif #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #include <Windows.h> #include <mmsystem.h> #pragma comment(lib, "winmm.lib") #endif namespace mitiru::audio

EM_JS(void, mitiru_webaudio_init, (), { if (!Module._mitiru_audioCtx) { Module._mitiru_audioCtx = new (window.AudioContext || window.webkitAudioContext)(); Module._mitiru_gainNode = Module._mitiru_audioCtx.createGain(); Module._mitiru_gainNode.connect(Module._mitiru_audioCtx.destination); Module._mitiru_sources = {}; } })

EM_JS(void, mitiru_webaudio_play, (const char* pathPtr), { var path = UTF8ToString(pathPtr); var ctx = Module._mitiru_audioCtx; if (!ctx) return; if (ctx.state === 'suspended') { ctx.resume(); } fetch(path) .then(function(response) { return response.arrayBuffer(); }) .then(function(buffer) { return ctx.decodeAudioData(buffer); }) .then(function(decoded) { if (Module._mitiru_sources[path]) { try { Module._mitiru_sources[path].stop(); } catch(e) {} } var source = ctx.createBufferSource(); source.buffer = decoded; source.connect(Module._mitiru_gainNode); source.start(0); Module._mitiru_sources[path] = source; }); })

EM_JS(void, mitiru_webaudio_stop, (const char* pathPtr), { var path = UTF8ToString(pathPtr); if (Module._mitiru_sources && Module._mitiru_sources[path]) { try { Module._mitiru_sources[path].stop(); } catch(e) {} delete Module._mitiru_sources[path]; } })

EM_JS(void, mitiru_webaudio_stop_all, (), { if (!Module._mitiru_sources) return; var keys = Object.keys(Module._mitiru_sources); for (var i = 0; i < keys.length; i++) { try { Module._mitiru_sources[keys[i]].stop(); } catch(e) {} } Module._mitiru_sources = {}; })

EM_JS(void, mitiru_webaudio_set_volume, (float vol), { if (Module._mitiru_gainNode) { Module._mitiru_gainNode.gain.value = vol; } })

class WebAudioEngine : public IAudioEngine 8

WebAudioEngine()

void playSound(std::string_view id) override

void stopSound(std::string_view id) override

void playMusic(std::string_view id) override

void stopMusic() override

void setVolume(float volume) override

[[nodiscard]] bool isPlaying(std::string_view id) const override

#pragma once #ifdef _WIN32 #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #ifndef NOMINMAX #define NOMINMAX #endif #include <Windows.h> #include <mmsystem.h> #pragma comment(lib, "winmm.lib") #include <algorithm> #include <array> #include <cstdint> #include <cstring> #include <vector> namespace mitiru::audio

enum AudioBackend : uint8_t 6

Auto

Fmod

Null

[[nodiscard]] inline std::unique_ptr<IAudioEngine> createAudioEngine( AudioBackend backend = AudioBackend::Auto)

[[nodiscard]] inline constexpr const char* availableAudioEngineName() noexcept

[[nodiscard]] inline constexpr bool hasFmodSupport() noexcept

class FmodAudioEngine : public IAudioEngine 19

explicit FmodAudioEngine(const Config& config = {})

~FmodAudioEngine() override

FmodAudioEngine(const FmodAudioEngine&) = delete

FmodAudioEngine& operator=(const FmodAudioEngine&) = delete

FmodAudioEngine(FmodAudioEngine&&) = delete

FmodAudioEngine& operator=(FmodAudioEngine&&) = delete

void playSound(std::string_view id) override

void stopSound(std::string_view id) override

void playMusic(std::string_view id) override

void stopMusic() override

void setVolume(float volume) override

[[nodiscard]] bool isPlaying(std::string_view id) const override

void update()

bool loadSound(std::string_view id, bool stream = false)

void setPitch(std::string_view id, float pitch)

void setPan(std::string_view id, float pan)

void setListenerPosition( const AudioVec3& position, const AudioVec3& forward = {0, 0, -1}, const AudioVec3& up = {0, 1, 0})

void setSoundPosition(std::string_view id, const AudioVec3& position)

[[nodiscard]] FMOD_SYSTEM* systemHandle() const noexcept

class FmodAudioEngine : public IAudioEngine 9

FmodAudioEngine()

explicit FmodAudioEngine(const Config& )

void playSound(std::string_view ) override

void stopSound(std::string_view ) override

void playMusic(std::string_view ) override

void stopMusic() override

void setVolume(float ) override

[[nodiscard]] bool isPlaying(std::string_view ) const override

void update()

class FmodStudioEngine 15

explicit FmodStudioEngine(int maxChannels = 512)

~FmodStudioEngine()

FmodStudioEngine(const FmodStudioEngine&) = delete

FmodStudioEngine& operator=(const FmodStudioEngine&) = delete

FmodStudioEngine(FmodStudioEngine&&) = delete

FmodStudioEngine& operator=(FmodStudioEngine&&) = delete

void update()

bool loadBank(std::string_view path)

void unloadBank(std::string_view path)

bool playEvent(std::string_view eventPath)

void stopEvent(std::string_view eventPath, bool allowFadeout = true)

bool setParameter(std::string_view eventPath, std::string_view paramName, float value)

bool setGlobalParameter(std::string_view paramName, float value)

[[nodiscard]] FMOD_STUDIO_EVENTINSTANCE* getEventInstance(std::string_view eventPath) const

[[nodiscard]] FMOD_STUDIO_SYSTEM* studioSystemHandle() const noexcept

class FmodStudioEngine 8

explicit FmodStudioEngine(int = 512)

void update()

bool loadBank(std::string_view )

void unloadBank(std::string_view )

bool playEvent(std::string_view )

void stopEvent(std::string_view , bool = true)

bool setParameter(std::string_view , std::string_view , float )

bool setGlobalParameter(std::string_view , float )

---

Sourced from docs/API_CATALOG.md, auto-generated by tools/generate_api_catalog.py.