##[[

if not MINIAUDIO_NO_IMPL then

cdefine 'MA_API static'

cdefine 'MA_NO_PTHREAD_IN_HEADER'

cdefine 'MINIAUDIO_IMPLEMENTATION'

end

cinclude 'miniaudio.h'

if ccinfo.is_linux then

linklib 'dl'

linklib 'm'

cflags '-pthread'

elseif ccinfo.is_windows then

linklib 'ole32'

end

]]

global ma_bool8: type = @cuchar

global ma_bool32: type = @cuint

global ma_handle: type = @pointer

global ma_ptr: type = @pointer

global ma_proc: type <cimport,nodecl> = @function(): void

global ma_pthread_mutex_t: type <cimport,nodecl> = @union{

__data: [40]cchar,

__alignment: uint64

}

global ma_pthread_cond_t: type <cimport,nodecl> = @union{

__data: [48]cchar,

__alignment: uint64

}

global ma_log_level: type <cimport,nodecl,using> = @enum(cint){

MA_LOG_LEVEL_DEBUG = 4,

MA_LOG_LEVEL_INFO = 3,

MA_LOG_LEVEL_WARNING = 2,

MA_LOG_LEVEL_ERROR = 1

}

global ma_context: type <cimport,nodecl,forwarddecl> = @record{}

global ma_device: type <cimport,nodecl,forwarddecl> = @record{}

global ma_channel: type = @cuchar

global ma_result: type <cimport,nodecl,using> = @enum(cint){

MA_SUCCESS = 0,

MA_ERROR = -1,

MA_INVALID_ARGS = -2,

MA_INVALID_OPERATION = -3,

MA_OUT_OF_MEMORY = -4,

MA_OUT_OF_RANGE = -5,

MA_ACCESS_DENIED = -6,

MA_DOES_NOT_EXIST = -7,

MA_ALREADY_EXISTS = -8,

MA_TOO_MANY_OPEN_FILES = -9,

MA_INVALID_FILE = -10,

MA_TOO_BIG = -11,

MA_PATH_TOO_LONG = -12,

MA_NAME_TOO_LONG = -13,

MA_NOT_DIRECTORY = -14,

MA_IS_DIRECTORY = -15,

MA_DIRECTORY_NOT_EMPTY = -16,

MA_AT_END = -17,

MA_NO_SPACE = -18,

MA_BUSY = -19,

MA_IO_ERROR = -20,

MA_INTERRUPT = -21,

MA_UNAVAILABLE = -22,

MA_ALREADY_IN_USE = -23,

MA_BAD_ADDRESS = -24,

MA_BAD_SEEK = -25,

MA_BAD_PIPE = -26,

MA_DEADLOCK = -27,

MA_TOO_MANY_LINKS = -28,

MA_NOT_IMPLEMENTED = -29,

MA_NO_MESSAGE = -30,

MA_BAD_MESSAGE = -31,

MA_NO_DATA_AVAILABLE = -32,

MA_INVALID_DATA = -33,

MA_TIMEOUT = -34,

MA_NO_NETWORK = -35,

MA_NOT_UNIQUE = -36,

MA_NOT_SOCKET = -37,

MA_NO_ADDRESS = -38,

MA_BAD_PROTOCOL = -39,

MA_PROTOCOL_UNAVAILABLE = -40,

MA_PROTOCOL_NOT_SUPPORTED = -41,

MA_PROTOCOL_FAMILY_NOT_SUPPORTED = -42,

MA_ADDRESS_FAMILY_NOT_SUPPORTED = -43,

MA_SOCKET_NOT_SUPPORTED = -44,

MA_CONNECTION_RESET = -45,

MA_ALREADY_CONNECTED = -46,

MA_NOT_CONNECTED = -47,

MA_CONNECTION_REFUSED = -48,

MA_NO_HOST = -49,

MA_IN_PROGRESS = -50,

MA_CANCELLED = -51,

MA_MEMORY_ALREADY_MAPPED = -52,

MA_FORMAT_NOT_SUPPORTED = -100,

MA_DEVICE_TYPE_NOT_SUPPORTED = -101,

MA_SHARE_MODE_NOT_SUPPORTED = -102,

MA_NO_BACKEND = -103,

MA_NO_DEVICE = -104,

MA_API_NOT_FOUND = -105,

MA_INVALID_DEVICE_CONFIG = -106,

MA_LOOP = -107,

MA_BACKEND_NOT_ENABLED = -108,

MA_DEVICE_NOT_INITIALIZED = -200,

MA_DEVICE_ALREADY_INITIALIZED = -201,

MA_DEVICE_NOT_STARTED = -202,

MA_DEVICE_NOT_STOPPED = -203,

MA_FAILED_TO_INIT_BACKEND = -300,

MA_FAILED_TO_OPEN_BACKEND_DEVICE = -301,

MA_FAILED_TO_START_BACKEND_DEVICE = -302,

MA_FAILED_TO_STOP_BACKEND_DEVICE = -303

}

global ma_stream_format: type <cimport,nodecl,using> = @enum(cint){

ma_stream_format_pcm = 0

}

global ma_stream_layout: type <cimport,nodecl,using> = @enum(cint){

ma_stream_layout_interleaved = 0,

ma_stream_layout_deinterleaved = 1

}

global ma_dither_mode: type <cimport,nodecl,using> = @enum(cint){

ma_dither_mode_none = 0,

ma_dither_mode_rectangle = 1,

ma_dither_mode_triangle = 2

}

global ma_format: type <cimport,nodecl,using> = @enum(cint){

ma_format_unknown = 0,

ma_format_u8 = 1,

ma_format_s16 = 2,

ma_format_s24 = 3,

ma_format_s32 = 4,

ma_format_f32 = 5,

ma_format_count = 6

}

global ma_standard_sample_rate: type <cimport,nodecl,using> = @enum(cint){

ma_standard_sample_rate_48000 = 48000,

ma_standard_sample_rate_44100 = 44100,

ma_standard_sample_rate_32000 = 32000,

ma_standard_sample_rate_24000 = 24000,

ma_standard_sample_rate_22050 = 22050,

ma_standard_sample_rate_88200 = 88200,

ma_standard_sample_rate_96000 = 96000,

ma_standard_sample_rate_176400 = 176400,

ma_standard_sample_rate_192000 = 192000,

ma_standard_sample_rate_16000 = 16000,

ma_standard_sample_rate_11025 = 11250,

ma_standard_sample_rate_8000 = 8000,

ma_standard_sample_rate_352800 = 352800,

ma_standard_sample_rate_384000 = 384000,

ma_standard_sample_rate_min = 8000,

ma_standard_sample_rate_max = 384000,

ma_standard_sample_rate_count = 14

}

global ma_channel_mix_mode: type <cimport,nodecl,using> = @enum(cint){

ma_channel_mix_mode_rectangular = 0,

ma_channel_mix_mode_simple = 1,

ma_channel_mix_mode_custom_weights = 2,

ma_channel_mix_mode_default = 0

}

global ma_standard_channel_map: type <cimport,nodecl,using> = @enum(cint){

ma_standard_channel_map_microsoft = 0,

ma_standard_channel_map_alsa = 1,

ma_standard_channel_map_rfc3551 = 2,

ma_standard_channel_map_flac = 3,

ma_standard_channel_map_vorbis = 4,

ma_standard_channel_map_sound4 = 5,

ma_standard_channel_map_sndio = 6,

ma_standard_channel_map_webaudio = 3,

ma_standard_channel_map_default = 0

}

global ma_performance_profile: type <cimport,nodecl,using> = @enum(cint){

ma_performance_profile_low_latency = 0,

ma_performance_profile_conservative = 1

}

global ma_allocation_callbacks: type <cimport,nodecl> = @record{

pUserData: pointer,

onMalloc: function(csize, pointer): pointer,

onRealloc: function(pointer, csize, pointer): pointer,

onFree: function(pointer, pointer): void

}

global ma_lcg: type <cimport,nodecl> = @record{

state: int32

}

global ma_atomic_uint32: type <cimport,nodecl,aligned(4)> = @record{

value: uint32

}

global ma_atomic_int32: type <cimport,nodecl,aligned(4)> = @record{

value: int32

}

global ma_atomic_uint64: type <cimport,nodecl,aligned(8)> = @record{

value: uint64

}

global ma_atomic_float: type <cimport,nodecl,aligned(4)> = @record{

value: float32

}

global ma_atomic_bool32: type <cimport,nodecl,aligned(4)> = @record{

value: ma_bool32

}

global ma_thread_priority: type <cimport,nodecl,using> = @enum(cint){

ma_thread_priority_idle = -5,

ma_thread_priority_lowest = -4,

ma_thread_priority_low = -3,

ma_thread_priority_normal = -2,

ma_thread_priority_high = -1,

ma_thread_priority_highest = 0,

ma_thread_priority_realtime = 1,

ma_thread_priority_default = 0

}

global ma_mutex: type = @ma_pthread_mutex_t

global ma_event: type <cimport,nodecl> = @record{

value: uint32,

lock: ma_pthread_mutex_t,

cond: ma_pthread_cond_t

}

global ma_semaphore: type <cimport,nodecl> = @record{

value: cint,

lock: ma_pthread_mutex_t,

cond: ma_pthread_cond_t

}

global function ma_version(pMajor: *uint32, pMinor: *uint32, pRevision: *uint32): void <cimport,nodecl> end

global function ma_version_string(): cstring <cimport,nodecl> end

global ma_log_callback_proc: type <cimport,nodecl> = @function(pointer, uint32, cstring): void

global ma_log_callback: type <cimport,nodecl> = @record{

onLog: ma_log_callback_proc,

pUserData: pointer

}

global function ma_log_callback_init(onLog: ma_log_callback_proc, pUserData: pointer): ma_log_callback <cimport,nodecl> end

global ma_log: type <cimport,nodecl> = @record{

callbacks: [4]ma_log_callback,

callbackCount: uint32,

allocationCallbacks: ma_allocation_callbacks,

lock: ma_mutex

}

global function ma_log_init(pAllocationCallbacks: *ma_allocation_callbacks, pLog: *ma_log): ma_result <cimport,nodecl> end

global function ma_log_uninit(pLog: *ma_log): void <cimport,nodecl> end

global function ma_log_register_callback(pLog: *ma_log, callback: ma_log_callback): ma_result <cimport,nodecl> end

global function ma_log_unregister_callback(pLog: *ma_log, callback: ma_log_callback): ma_result <cimport,nodecl> end

global function ma_log_post(pLog: *ma_log, level: uint32, pMessage: cstring): ma_result <cimport,nodecl> end

global function ma_log_postv(pLog: *ma_log, level: uint32, pFormat: cstring, args: cvalist): ma_result <cimport,nodecl> end

global function ma_log_postf(pLog: *ma_log, level: uint32, pFormat: cstring, ...: cvarargs): ma_result <cimport,nodecl> end

global ma_biquad_coefficient: type <cimport,nodecl> = @union{

f32: float32,

s32: int32

}

global ma_biquad_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

b0: float64,

b1: float64,

b2: float64,

a0: float64,

a1: float64,

a2: float64

}

global function ma_biquad_config_init(format: ma_format, channels: uint32, b0: float64, b1: float64, b2: float64, a0: float64, a1: float64, a2: float64): ma_biquad_config <cimport,nodecl> end

global ma_biquad: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

b0: ma_biquad_coefficient,

b1: ma_biquad_coefficient,

b2: ma_biquad_coefficient,

a1: ma_biquad_coefficient,

a2: ma_biquad_coefficient,

pR1: *ma_biquad_coefficient,

pR2: *ma_biquad_coefficient,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_biquad_get_heap_size(pConfig: *ma_biquad_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_biquad_init_preallocated(pConfig: *ma_biquad_config, pHeap: pointer, pBQ: *ma_biquad): ma_result <cimport,nodecl> end

global function ma_biquad_init(pConfig: *ma_biquad_config, pAllocationCallbacks: *ma_allocation_callbacks, pBQ: *ma_biquad): ma_result <cimport,nodecl> end

global function ma_biquad_uninit(pBQ: *ma_biquad, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_biquad_reinit(pConfig: *ma_biquad_config, pBQ: *ma_biquad): ma_result <cimport,nodecl> end

global function ma_biquad_clear_cache(pBQ: *ma_biquad): ma_result <cimport,nodecl> end

global function ma_biquad_process_pcm_frames(pBQ: *ma_biquad, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_biquad_get_latency(pBQ: *ma_biquad): uint32 <cimport,nodecl> end

global ma_lpf1_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

cutoffFrequency: float64,

q: float64

}

global ma_lpf2_config: type = @ma_lpf1_config

global function ma_lpf1_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64): ma_lpf1_config <cimport,nodecl> end

global function ma_lpf2_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64, q: float64): ma_lpf2_config <cimport,nodecl> end

global ma_lpf1: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

a: ma_biquad_coefficient,

pR1: *ma_biquad_coefficient,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_lpf1_get_heap_size(pConfig: *ma_lpf1_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_lpf1_init_preallocated(pConfig: *ma_lpf1_config, pHeap: pointer, pLPF: *ma_lpf1): ma_result <cimport,nodecl> end

global function ma_lpf1_init(pConfig: *ma_lpf1_config, pAllocationCallbacks: *ma_allocation_callbacks, pLPF: *ma_lpf1): ma_result <cimport,nodecl> end

global function ma_lpf1_uninit(pLPF: *ma_lpf1, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_lpf1_reinit(pConfig: *ma_lpf1_config, pLPF: *ma_lpf1): ma_result <cimport,nodecl> end

global function ma_lpf1_clear_cache(pLPF: *ma_lpf1): ma_result <cimport,nodecl> end

global function ma_lpf1_process_pcm_frames(pLPF: *ma_lpf1, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_lpf1_get_latency(pLPF: *ma_lpf1): uint32 <cimport,nodecl> end

global ma_lpf2: type <cimport,nodecl> = @record{

bq: ma_biquad

}

global function ma_lpf2_get_heap_size(pConfig: *ma_lpf2_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_lpf2_init_preallocated(pConfig: *ma_lpf2_config, pHeap: pointer, pHPF: *ma_lpf2): ma_result <cimport,nodecl> end

global function ma_lpf2_init(pConfig: *ma_lpf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pLPF: *ma_lpf2): ma_result <cimport,nodecl> end

global function ma_lpf2_uninit(pLPF: *ma_lpf2, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_lpf2_reinit(pConfig: *ma_lpf2_config, pLPF: *ma_lpf2): ma_result <cimport,nodecl> end

global function ma_lpf2_clear_cache(pLPF: *ma_lpf2): ma_result <cimport,nodecl> end

global function ma_lpf2_process_pcm_frames(pLPF: *ma_lpf2, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_lpf2_get_latency(pLPF: *ma_lpf2): uint32 <cimport,nodecl> end

global ma_lpf_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

cutoffFrequency: float64,

order: uint32

}

global function ma_lpf_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64, order: uint32): ma_lpf_config <cimport,nodecl> end

global ma_lpf: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

lpf1Count: uint32,

lpf2Count: uint32,

pLPF1: *ma_lpf1,

pLPF2: *ma_lpf2,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_lpf_get_heap_size(pConfig: *ma_lpf_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_lpf_init_preallocated(pConfig: *ma_lpf_config, pHeap: pointer, pLPF: *ma_lpf): ma_result <cimport,nodecl> end

global function ma_lpf_init(pConfig: *ma_lpf_config, pAllocationCallbacks: *ma_allocation_callbacks, pLPF: *ma_lpf): ma_result <cimport,nodecl> end

global function ma_lpf_uninit(pLPF: *ma_lpf, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_lpf_reinit(pConfig: *ma_lpf_config, pLPF: *ma_lpf): ma_result <cimport,nodecl> end

global function ma_lpf_clear_cache(pLPF: *ma_lpf): ma_result <cimport,nodecl> end

global function ma_lpf_process_pcm_frames(pLPF: *ma_lpf, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_lpf_get_latency(pLPF: *ma_lpf): uint32 <cimport,nodecl> end

global ma_hpf1_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

cutoffFrequency: float64,

q: float64

}

global ma_hpf2_config: type = @ma_hpf1_config

global function ma_hpf1_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64): ma_hpf1_config <cimport,nodecl> end

global function ma_hpf2_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64, q: float64): ma_hpf2_config <cimport,nodecl> end

global ma_hpf1: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

a: ma_biquad_coefficient,

pR1: *ma_biquad_coefficient,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_hpf1_get_heap_size(pConfig: *ma_hpf1_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_hpf1_init_preallocated(pConfig: *ma_hpf1_config, pHeap: pointer, pLPF: *ma_hpf1): ma_result <cimport,nodecl> end

global function ma_hpf1_init(pConfig: *ma_hpf1_config, pAllocationCallbacks: *ma_allocation_callbacks, pHPF: *ma_hpf1): ma_result <cimport,nodecl> end

global function ma_hpf1_uninit(pHPF: *ma_hpf1, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_hpf1_reinit(pConfig: *ma_hpf1_config, pHPF: *ma_hpf1): ma_result <cimport,nodecl> end

global function ma_hpf1_process_pcm_frames(pHPF: *ma_hpf1, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_hpf1_get_latency(pHPF: *ma_hpf1): uint32 <cimport,nodecl> end

global ma_hpf2: type <cimport,nodecl> = @record{

bq: ma_biquad

}

global function ma_hpf2_get_heap_size(pConfig: *ma_hpf2_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_hpf2_init_preallocated(pConfig: *ma_hpf2_config, pHeap: pointer, pHPF: *ma_hpf2): ma_result <cimport,nodecl> end

global function ma_hpf2_init(pConfig: *ma_hpf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pHPF: *ma_hpf2): ma_result <cimport,nodecl> end

global function ma_hpf2_uninit(pHPF: *ma_hpf2, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_hpf2_reinit(pConfig: *ma_hpf2_config, pHPF: *ma_hpf2): ma_result <cimport,nodecl> end

global function ma_hpf2_process_pcm_frames(pHPF: *ma_hpf2, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_hpf2_get_latency(pHPF: *ma_hpf2): uint32 <cimport,nodecl> end

global ma_hpf_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

cutoffFrequency: float64,

order: uint32

}

global function ma_hpf_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64, order: uint32): ma_hpf_config <cimport,nodecl> end

global ma_hpf: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

hpf1Count: uint32,

hpf2Count: uint32,

pHPF1: *ma_hpf1,

pHPF2: *ma_hpf2,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_hpf_get_heap_size(pConfig: *ma_hpf_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_hpf_init_preallocated(pConfig: *ma_hpf_config, pHeap: pointer, pLPF: *ma_hpf): ma_result <cimport,nodecl> end

global function ma_hpf_init(pConfig: *ma_hpf_config, pAllocationCallbacks: *ma_allocation_callbacks, pHPF: *ma_hpf): ma_result <cimport,nodecl> end

global function ma_hpf_uninit(pHPF: *ma_hpf, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_hpf_reinit(pConfig: *ma_hpf_config, pHPF: *ma_hpf): ma_result <cimport,nodecl> end

global function ma_hpf_process_pcm_frames(pHPF: *ma_hpf, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_hpf_get_latency(pHPF: *ma_hpf): uint32 <cimport,nodecl> end

global ma_bpf2_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

cutoffFrequency: float64,

q: float64

}

global function ma_bpf2_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64, q: float64): ma_bpf2_config <cimport,nodecl> end

global ma_bpf2: type <cimport,nodecl> = @record{

bq: ma_biquad

}

global function ma_bpf2_get_heap_size(pConfig: *ma_bpf2_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_bpf2_init_preallocated(pConfig: *ma_bpf2_config, pHeap: pointer, pBPF: *ma_bpf2): ma_result <cimport,nodecl> end

global function ma_bpf2_init(pConfig: *ma_bpf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pBPF: *ma_bpf2): ma_result <cimport,nodecl> end

global function ma_bpf2_uninit(pBPF: *ma_bpf2, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_bpf2_reinit(pConfig: *ma_bpf2_config, pBPF: *ma_bpf2): ma_result <cimport,nodecl> end

global function ma_bpf2_process_pcm_frames(pBPF: *ma_bpf2, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_bpf2_get_latency(pBPF: *ma_bpf2): uint32 <cimport,nodecl> end

global ma_bpf_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

cutoffFrequency: float64,

order: uint32

}

global function ma_bpf_config_init(format: ma_format, channels: uint32, sampleRate: uint32, cutoffFrequency: float64, order: uint32): ma_bpf_config <cimport,nodecl> end

global ma_bpf: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

bpf2Count: uint32,

pBPF2: *ma_bpf2,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_bpf_get_heap_size(pConfig: *ma_bpf_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_bpf_init_preallocated(pConfig: *ma_bpf_config, pHeap: pointer, pBPF: *ma_bpf): ma_result <cimport,nodecl> end

global function ma_bpf_init(pConfig: *ma_bpf_config, pAllocationCallbacks: *ma_allocation_callbacks, pBPF: *ma_bpf): ma_result <cimport,nodecl> end

global function ma_bpf_uninit(pBPF: *ma_bpf, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_bpf_reinit(pConfig: *ma_bpf_config, pBPF: *ma_bpf): ma_result <cimport,nodecl> end

global function ma_bpf_process_pcm_frames(pBPF: *ma_bpf, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_bpf_get_latency(pBPF: *ma_bpf): uint32 <cimport,nodecl> end

global ma_notch2_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

q: float64,

frequency: float64

}

global ma_notch_config: type = @ma_notch2_config

global function ma_notch2_config_init(format: ma_format, channels: uint32, sampleRate: uint32, q: float64, frequency: float64): ma_notch2_config <cimport,nodecl> end

global ma_notch2: type <cimport,nodecl> = @record{

bq: ma_biquad

}

global function ma_notch2_get_heap_size(pConfig: *ma_notch2_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_notch2_init_preallocated(pConfig: *ma_notch2_config, pHeap: pointer, pFilter: *ma_notch2): ma_result <cimport,nodecl> end

global function ma_notch2_init(pConfig: *ma_notch2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_notch2): ma_result <cimport,nodecl> end

global function ma_notch2_uninit(pFilter: *ma_notch2, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_notch2_reinit(pConfig: *ma_notch2_config, pFilter: *ma_notch2): ma_result <cimport,nodecl> end

global function ma_notch2_process_pcm_frames(pFilter: *ma_notch2, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_notch2_get_latency(pFilter: *ma_notch2): uint32 <cimport,nodecl> end

global ma_peak2_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

gainDB: float64,

q: float64,

frequency: float64

}

global ma_peak_config: type = @ma_peak2_config

global function ma_peak2_config_init(format: ma_format, channels: uint32, sampleRate: uint32, gainDB: float64, q: float64, frequency: float64): ma_peak2_config <cimport,nodecl> end

global ma_peak2: type <cimport,nodecl> = @record{

bq: ma_biquad

}

global function ma_peak2_get_heap_size(pConfig: *ma_peak2_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_peak2_init_preallocated(pConfig: *ma_peak2_config, pHeap: pointer, pFilter: *ma_peak2): ma_result <cimport,nodecl> end

global function ma_peak2_init(pConfig: *ma_peak2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_peak2): ma_result <cimport,nodecl> end

global function ma_peak2_uninit(pFilter: *ma_peak2, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_peak2_reinit(pConfig: *ma_peak2_config, pFilter: *ma_peak2): ma_result <cimport,nodecl> end

global function ma_peak2_process_pcm_frames(pFilter: *ma_peak2, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_peak2_get_latency(pFilter: *ma_peak2): uint32 <cimport,nodecl> end

global ma_loshelf2_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

gainDB: float64,

shelfSlope: float64,

frequency: float64

}

global ma_loshelf_config: type = @ma_loshelf2_config

global function ma_loshelf2_config_init(format: ma_format, channels: uint32, sampleRate: uint32, gainDB: float64, shelfSlope: float64, frequency: float64): ma_loshelf2_config <cimport,nodecl> end

global ma_loshelf2: type <cimport,nodecl> = @record{

bq: ma_biquad

}

global function ma_loshelf2_get_heap_size(pConfig: *ma_loshelf2_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_loshelf2_init_preallocated(pConfig: *ma_loshelf2_config, pHeap: pointer, pFilter: *ma_loshelf2): ma_result <cimport,nodecl> end

global function ma_loshelf2_init(pConfig: *ma_loshelf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_loshelf2): ma_result <cimport,nodecl> end

global function ma_loshelf2_uninit(pFilter: *ma_loshelf2, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_loshelf2_reinit(pConfig: *ma_loshelf2_config, pFilter: *ma_loshelf2): ma_result <cimport,nodecl> end

global function ma_loshelf2_process_pcm_frames(pFilter: *ma_loshelf2, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_loshelf2_get_latency(pFilter: *ma_loshelf2): uint32 <cimport,nodecl> end

global ma_hishelf2_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32,

gainDB: float64,

shelfSlope: float64,

frequency: float64

}

global ma_hishelf_config: type = @ma_hishelf2_config

global function ma_hishelf2_config_init(format: ma_format, channels: uint32, sampleRate: uint32, gainDB: float64, shelfSlope: float64, frequency: float64): ma_hishelf2_config <cimport,nodecl> end

global ma_hishelf2: type <cimport,nodecl> = @record{

bq: ma_biquad

}

global function ma_hishelf2_get_heap_size(pConfig: *ma_hishelf2_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_hishelf2_init_preallocated(pConfig: *ma_hishelf2_config, pHeap: pointer, pFilter: *ma_hishelf2): ma_result <cimport,nodecl> end

global function ma_hishelf2_init(pConfig: *ma_hishelf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_hishelf2): ma_result <cimport,nodecl> end

global function ma_hishelf2_uninit(pFilter: *ma_hishelf2, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_hishelf2_reinit(pConfig: *ma_hishelf2_config, pFilter: *ma_hishelf2): ma_result <cimport,nodecl> end

global function ma_hishelf2_process_pcm_frames(pFilter: *ma_hishelf2, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_hishelf2_get_latency(pFilter: *ma_hishelf2): uint32 <cimport,nodecl> end

global ma_delay_config: type <cimport,nodecl> = @record{

channels: uint32,

sampleRate: uint32,

delayInFrames: uint32,

delayStart: ma_bool32,

wet: float32,

dry: float32,

decay: float32

}

global function ma_delay_config_init(channels: uint32, sampleRate: uint32, delayInFrames: uint32, decay: float32): ma_delay_config <cimport,nodecl> end

global ma_delay: type <cimport,nodecl> = @record{

config: ma_delay_config,

cursor: uint32,

bufferSizeInFrames: uint32,

pBuffer: *float32

}

global function ma_delay_init(pConfig: *ma_delay_config, pAllocationCallbacks: *ma_allocation_callbacks, pDelay: *ma_delay): ma_result <cimport,nodecl> end

global function ma_delay_uninit(pDelay: *ma_delay, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_delay_process_pcm_frames(pDelay: *ma_delay, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint32): ma_result <cimport,nodecl> end

global function ma_delay_set_wet(pDelay: *ma_delay, value: float32): void <cimport,nodecl> end

global function ma_delay_get_wet(pDelay: *ma_delay): float32 <cimport,nodecl> end

global function ma_delay_set_dry(pDelay: *ma_delay, value: float32): void <cimport,nodecl> end

global function ma_delay_get_dry(pDelay: *ma_delay): float32 <cimport,nodecl> end

global function ma_delay_set_decay(pDelay: *ma_delay, value: float32): void <cimport,nodecl> end

global function ma_delay_get_decay(pDelay: *ma_delay): float32 <cimport,nodecl> end

global ma_gainer_config: type <cimport,nodecl> = @record{

channels: uint32,

smoothTimeInFrames: uint32

}

global function ma_gainer_config_init(channels: uint32, smoothTimeInFrames: uint32): ma_gainer_config <cimport,nodecl> end

global ma_gainer: type <cimport,nodecl> = @record{

config: ma_gainer_config,

t: uint32,

masterVolume: float32,

pOldGains: *float32,

pNewGains: *float32,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_gainer_get_heap_size(pConfig: *ma_gainer_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_gainer_init_preallocated(pConfig: *ma_gainer_config, pHeap: pointer, pGainer: *ma_gainer): ma_result <cimport,nodecl> end

global function ma_gainer_init(pConfig: *ma_gainer_config, pAllocationCallbacks: *ma_allocation_callbacks, pGainer: *ma_gainer): ma_result <cimport,nodecl> end

global function ma_gainer_uninit(pGainer: *ma_gainer, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_gainer_process_pcm_frames(pGainer: *ma_gainer, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_gainer_set_gain(pGainer: *ma_gainer, newGain: float32): ma_result <cimport,nodecl> end

global function ma_gainer_set_gains(pGainer: *ma_gainer, pNewGains: *float32): ma_result <cimport,nodecl> end

global function ma_gainer_set_master_volume(pGainer: *ma_gainer, volume: float32): ma_result <cimport,nodecl> end

global function ma_gainer_get_master_volume(pGainer: *ma_gainer, pVolume: *float32): ma_result <cimport,nodecl> end

global ma_pan_mode: type <cimport,nodecl,using> = @enum(cint){

ma_pan_mode_balance = 0,

ma_pan_mode_pan = 1

}

global ma_panner_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

mode: ma_pan_mode,

pan: float32

}

global function ma_panner_config_init(format: ma_format, channels: uint32): ma_panner_config <cimport,nodecl> end

global ma_panner: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

mode: ma_pan_mode,

pan: float32

}

global function ma_panner_init(pConfig: *ma_panner_config, pPanner: *ma_panner): ma_result <cimport,nodecl> end

global function ma_panner_process_pcm_frames(pPanner: *ma_panner, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_panner_set_mode(pPanner: *ma_panner, mode: ma_pan_mode): void <cimport,nodecl> end

global function ma_panner_get_mode(pPanner: *ma_panner): ma_pan_mode <cimport,nodecl> end

global function ma_panner_set_pan(pPanner: *ma_panner, pan: float32): void <cimport,nodecl> end

global function ma_panner_get_pan(pPanner: *ma_panner): float32 <cimport,nodecl> end

global ma_fader_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRate: uint32

}

global function ma_fader_config_init(format: ma_format, channels: uint32, sampleRate: uint32): ma_fader_config <cimport,nodecl> end

global ma_fader: type <cimport,nodecl> = @record{

config: ma_fader_config,

volumeBeg: float32,

volumeEnd: float32,

lengthInFrames: uint64,

cursorInFrames: uint64

}

global function ma_fader_init(pConfig: *ma_fader_config, pFader: *ma_fader): ma_result <cimport,nodecl> end

global function ma_fader_process_pcm_frames(pFader: *ma_fader, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_fader_get_data_format(pFader: *ma_fader, pFormat: *ma_format, pChannels: *uint32, pSampleRate: *uint32): void <cimport,nodecl> end

global function ma_fader_set_fade(pFader: *ma_fader, volumeBeg: float32, volumeEnd: float32, lengthInFrames: uint64): void <cimport,nodecl> end

global function ma_fader_get_current_volume(pFader: *ma_fader): float32 <cimport,nodecl> end

global ma_vec3f: type <cimport,nodecl> = @record{

x: float32,

y: float32,

z: float32

}

global ma_atomic_vec3f: type <cimport,nodecl> = @record{

v: ma_vec3f,

lock: cuint

}

global ma_attenuation_model: type <cimport,nodecl,using> = @enum(cint){

ma_attenuation_model_none = 0,

ma_attenuation_model_inverse = 1,

ma_attenuation_model_linear = 2,

ma_attenuation_model_exponential = 3

}

global ma_positioning: type <cimport,nodecl,using> = @enum(cint){

ma_positioning_absolute = 0,

ma_positioning_relative = 1

}

global ma_handedness: type <cimport,nodecl,using> = @enum(cint){

ma_handedness_right = 0,

ma_handedness_left = 1

}

global ma_spatializer_listener_config: type <cimport,nodecl> = @record{

channelsOut: uint32,

pChannelMapOut: *ma_channel,

handedness: ma_handedness,

coneInnerAngleInRadians: float32,

coneOuterAngleInRadians: float32,

coneOuterGain: float32,

speedOfSound: float32,

worldUp: ma_vec3f

}

global function ma_spatializer_listener_config_init(channelsOut: uint32): ma_spatializer_listener_config <cimport,nodecl> end

global ma_spatializer_listener: type <cimport,nodecl> = @record{

config: ma_spatializer_listener_config,

position: ma_atomic_vec3f,

direction: ma_atomic_vec3f,

velocity: ma_atomic_vec3f,

isEnabled: ma_bool32,

_ownsHeap: ma_bool32,

_pHeap: pointer

}

global function ma_spatializer_listener_get_heap_size(pConfig: *ma_spatializer_listener_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_spatializer_listener_init_preallocated(pConfig: *ma_spatializer_listener_config, pHeap: pointer, pListener: *ma_spatializer_listener): ma_result <cimport,nodecl> end

global function ma_spatializer_listener_init(pConfig: *ma_spatializer_listener_config, pAllocationCallbacks: *ma_allocation_callbacks, pListener: *ma_spatializer_listener): ma_result <cimport,nodecl> end

global function ma_spatializer_listener_uninit(pListener: *ma_spatializer_listener, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_spatializer_listener_get_channel_map(pListener: *ma_spatializer_listener): *ma_channel <cimport,nodecl> end

global function ma_spatializer_listener_set_cone(pListener: *ma_spatializer_listener, innerAngleInRadians: float32, outerAngleInRadians: float32, outerGain: float32): void <cimport,nodecl> end

global function ma_spatializer_listener_get_cone(pListener: *ma_spatializer_listener, pInnerAngleInRadians: *float32, pOuterAngleInRadians: *float32, pOuterGain: *float32): void <cimport,nodecl> end

global function ma_spatializer_listener_set_position(pListener: *ma_spatializer_listener, x: float32, y: float32, z: float32): void <cimport,nodecl> end

global function ma_spatializer_listener_get_position(pListener: *ma_spatializer_listener): ma_vec3f <cimport,nodecl> end

global function ma_spatializer_listener_set_direction(pListener: *ma_spatializer_listener, x: float32, y: float32, z: float32): void <cimport,nodecl> end

global function ma_spatializer_listener_get_direction(pListener: *ma_spatializer_listener): ma_vec3f <cimport,nodecl> end

global function ma_spatializer_listener_set_velocity(pListener: *ma_spatializer_listener, x: float32, y: float32, z: float32): void <cimport,nodecl> end

global function ma_spatializer_listener_get_velocity(pListener: *ma_spatializer_listener): ma_vec3f <cimport,nodecl> end

global function ma_spatializer_listener_set_speed_of_sound(pListener: *ma_spatializer_listener, speedOfSound: float32): void <cimport,nodecl> end

global function ma_spatializer_listener_get_speed_of_sound(pListener: *ma_spatializer_listener): float32 <cimport,nodecl> end

global function ma_spatializer_listener_set_world_up(pListener: *ma_spatializer_listener, x: float32, y: float32, z: float32): void <cimport,nodecl> end

global function ma_spatializer_listener_get_world_up(pListener: *ma_spatializer_listener): ma_vec3f <cimport,nodecl> end

global function ma_spatializer_listener_set_enabled(pListener: *ma_spatializer_listener, isEnabled: ma_bool32): void <cimport,nodecl> end

global function ma_spatializer_listener_is_enabled(pListener: *ma_spatializer_listener): ma_bool32 <cimport,nodecl> end

global ma_spatializer_config: type <cimport,nodecl> = @record{

channelsIn: uint32,

channelsOut: uint32,

pChannelMapIn: *ma_channel,

attenuationModel: ma_attenuation_model,

positioning: ma_positioning,

handedness: ma_handedness,

minGain: float32,

maxGain: float32,

minDistance: float32,

maxDistance: float32,

rolloff: float32,

coneInnerAngleInRadians: float32,

coneOuterAngleInRadians: float32,

coneOuterGain: float32,

dopplerFactor: float32,

directionalAttenuationFactor: float32,

minSpatializationChannelGain: float32,

gainSmoothTimeInFrames: uint32

}

global function ma_spatializer_config_init(channelsIn: uint32, channelsOut: uint32): ma_spatializer_config <cimport,nodecl> end

global ma_spatializer: type <cimport,nodecl> = @record{

channelsIn: uint32,

channelsOut: uint32,

pChannelMapIn: *ma_channel,

attenuationModel: ma_attenuation_model,

positioning: ma_positioning,

handedness: ma_handedness,

minGain: float32,

maxGain: float32,

minDistance: float32,

maxDistance: float32,

rolloff: float32,

coneInnerAngleInRadians: float32,

coneOuterAngleInRadians: float32,

coneOuterGain: float32,

dopplerFactor: float32,

directionalAttenuationFactor: float32,

gainSmoothTimeInFrames: uint32,

position: ma_atomic_vec3f,

direction: ma_atomic_vec3f,

velocity: ma_atomic_vec3f,

dopplerPitch: float32,

minSpatializationChannelGain: float32,

gainer: ma_gainer,

pNewChannelGainsOut: *float32,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_spatializer_get_heap_size(pConfig: *ma_spatializer_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_spatializer_init_preallocated(pConfig: *ma_spatializer_config, pHeap: pointer, pSpatializer: *ma_spatializer): ma_result <cimport,nodecl> end

global function ma_spatializer_init(pConfig: *ma_spatializer_config, pAllocationCallbacks: *ma_allocation_callbacks, pSpatializer: *ma_spatializer): ma_result <cimport,nodecl> end

global function ma_spatializer_uninit(pSpatializer: *ma_spatializer, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_spatializer_process_pcm_frames(pSpatializer: *ma_spatializer, pListener: *ma_spatializer_listener, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_spatializer_set_master_volume(pSpatializer: *ma_spatializer, volume: float32): ma_result <cimport,nodecl> end

global function ma_spatializer_get_master_volume(pSpatializer: *ma_spatializer, pVolume: *float32): ma_result <cimport,nodecl> end

global function ma_spatializer_get_input_channels(pSpatializer: *ma_spatializer): uint32 <cimport,nodecl> end

global function ma_spatializer_get_output_channels(pSpatializer: *ma_spatializer): uint32 <cimport,nodecl> end

global function ma_spatializer_set_attenuation_model(pSpatializer: *ma_spatializer, attenuationModel: ma_attenuation_model): void <cimport,nodecl> end

global function ma_spatializer_get_attenuation_model(pSpatializer: *ma_spatializer): ma_attenuation_model <cimport,nodecl> end

global function ma_spatializer_set_positioning(pSpatializer: *ma_spatializer, positioning: ma_positioning): void <cimport,nodecl> end

global function ma_spatializer_get_positioning(pSpatializer: *ma_spatializer): ma_positioning <cimport,nodecl> end

global function ma_spatializer_set_rolloff(pSpatializer: *ma_spatializer, rolloff: float32): void <cimport,nodecl> end

global function ma_spatializer_get_rolloff(pSpatializer: *ma_spatializer): float32 <cimport,nodecl> end

global function ma_spatializer_set_min_gain(pSpatializer: *ma_spatializer, minGain: float32): void <cimport,nodecl> end

global function ma_spatializer_get_min_gain(pSpatializer: *ma_spatializer): float32 <cimport,nodecl> end

global function ma_spatializer_set_max_gain(pSpatializer: *ma_spatializer, maxGain: float32): void <cimport,nodecl> end

global function ma_spatializer_get_max_gain(pSpatializer: *ma_spatializer): float32 <cimport,nodecl> end

global function ma_spatializer_set_min_distance(pSpatializer: *ma_spatializer, minDistance: float32): void <cimport,nodecl> end

global function ma_spatializer_get_min_distance(pSpatializer: *ma_spatializer): float32 <cimport,nodecl> end

global function ma_spatializer_set_max_distance(pSpatializer: *ma_spatializer, maxDistance: float32): void <cimport,nodecl> end

global function ma_spatializer_get_max_distance(pSpatializer: *ma_spatializer): float32 <cimport,nodecl> end

global function ma_spatializer_set_cone(pSpatializer: *ma_spatializer, innerAngleInRadians: float32, outerAngleInRadians: float32, outerGain: float32): void <cimport,nodecl> end

global function ma_spatializer_get_cone(pSpatializer: *ma_spatializer, pInnerAngleInRadians: *float32, pOuterAngleInRadians: *float32, pOuterGain: *float32): void <cimport,nodecl> end

global function ma_spatializer_set_doppler_factor(pSpatializer: *ma_spatializer, dopplerFactor: float32): void <cimport,nodecl> end

global function ma_spatializer_get_doppler_factor(pSpatializer: *ma_spatializer): float32 <cimport,nodecl> end

global function ma_spatializer_set_directional_attenuation_factor(pSpatializer: *ma_spatializer, directionalAttenuationFactor: float32): void <cimport,nodecl> end

global function ma_spatializer_get_directional_attenuation_factor(pSpatializer: *ma_spatializer): float32 <cimport,nodecl> end

global function ma_spatializer_set_position(pSpatializer: *ma_spatializer, x: float32, y: float32, z: float32): void <cimport,nodecl> end

global function ma_spatializer_get_position(pSpatializer: *ma_spatializer): ma_vec3f <cimport,nodecl> end

global function ma_spatializer_set_direction(pSpatializer: *ma_spatializer, x: float32, y: float32, z: float32): void <cimport,nodecl> end

global function ma_spatializer_get_direction(pSpatializer: *ma_spatializer): ma_vec3f <cimport,nodecl> end

global function ma_spatializer_set_velocity(pSpatializer: *ma_spatializer, x: float32, y: float32, z: float32): void <cimport,nodecl> end

global function ma_spatializer_get_velocity(pSpatializer: *ma_spatializer): ma_vec3f <cimport,nodecl> end

global function ma_spatializer_get_relative_position_and_direction(pSpatializer: *ma_spatializer, pListener: *ma_spatializer_listener, pRelativePos: *ma_vec3f, pRelativeDir: *ma_vec3f): void <cimport,nodecl> end

global ma_linear_resampler_config: type <cimport,nodecl> = @record{

format: ma_format,

channels: uint32,

sampleRateIn: uint32,

sampleRateOut: uint32,

lpfOrder: uint32,

lpfNyquistFactor: float64

}

global function ma_linear_resampler_config_init(format: ma_format, channels: uint32, sampleRateIn: uint32, sampleRateOut: uint32): ma_linear_resampler_config <cimport,nodecl> end

global ma_linear_resampler: type <cimport,nodecl> = @record{

config: ma_linear_resampler_config,

inAdvanceInt: uint32,

inAdvanceFrac: uint32,

inTimeInt: uint32,

inTimeFrac: uint32,

x0: union{

f32: *float32,

s16: *int16

},

x1: union{

f32: *float32,

s16: *int16

},

lpf: ma_lpf,

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_linear_resampler_get_heap_size(pConfig: *ma_linear_resampler_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_linear_resampler_init_preallocated(pConfig: *ma_linear_resampler_config, pHeap: pointer, pResampler: *ma_linear_resampler): ma_result <cimport,nodecl> end

global function ma_linear_resampler_init(pConfig: *ma_linear_resampler_config, pAllocationCallbacks: *ma_allocation_callbacks, pResampler: *ma_linear_resampler): ma_result <cimport,nodecl> end

global function ma_linear_resampler_uninit(pResampler: *ma_linear_resampler, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_linear_resampler_process_pcm_frames(pResampler: *ma_linear_resampler, pFramesIn: pointer, pFrameCountIn: *uint64, pFramesOut: pointer, pFrameCountOut: *uint64): ma_result <cimport,nodecl> end

global function ma_linear_resampler_set_rate(pResampler: *ma_linear_resampler, sampleRateIn: uint32, sampleRateOut: uint32): ma_result <cimport,nodecl> end

global function ma_linear_resampler_set_rate_ratio(pResampler: *ma_linear_resampler, ratioInOut: float32): ma_result <cimport,nodecl> end

global function ma_linear_resampler_get_input_latency(pResampler: *ma_linear_resampler): uint64 <cimport,nodecl> end

global function ma_linear_resampler_get_output_latency(pResampler: *ma_linear_resampler): uint64 <cimport,nodecl> end

global function ma_linear_resampler_get_required_input_frame_count(pResampler: *ma_linear_resampler, outputFrameCount: uint64, pInputFrameCount: *uint64): ma_result <cimport,nodecl> end

global function ma_linear_resampler_get_expected_output_frame_count(pResampler: *ma_linear_resampler, inputFrameCount: uint64, pOutputFrameCount: *uint64): ma_result <cimport,nodecl> end

global function ma_linear_resampler_reset(pResampler: *ma_linear_resampler): ma_result <cimport,nodecl> end

global ma_resampler_config: type <cimport,nodecl,forwarddecl> = @record{}

global ma_resampling_backend_vtable: type <cimport,nodecl> = @record{

onGetHeapSize: function(pointer, *ma_resampler_config, *csize): ma_result,

onInit: function(pointer, *ma_resampler_config, pointer, *pointer): ma_result,

onUninit: function(pointer, pointer, *ma_allocation_callbacks): void,

onProcess: function(pointer, pointer, pointer, *uint64, pointer, *uint64): ma_result,

onSetRate: function(pointer, pointer, uint32, uint32): ma_result,

onGetInputLatency: function(pointer, pointer): uint64,

onGetOutputLatency: function(pointer, pointer): uint64,

onGetRequiredInputFrameCount: function(pointer, pointer, uint64, *uint64): ma_result,

onGetExpectedOutputFrameCount: function(pointer, pointer, uint64, *uint64): ma_result,

onReset: function(pointer, pointer): ma_result

}

global ma_resample_algorithm: type <cimport,nodecl,using> = @enum(cint){

ma_resample_algorithm_linear = 0,

ma_resample_algorithm_custom = 1

}

ma_resampler_config = @record{

format: ma_format,

channels: uint32,

sampleRateIn: uint32,

sampleRateOut: uint32,

algorithm: ma_resample_algorithm,

pBackendVTable: *ma_resampling_backend_vtable,

pBackendUserData: pointer,

linear: record{

lpfOrder: uint32

}

}

global function ma_resampler_config_init(format: ma_format, channels: uint32, sampleRateIn: uint32, sampleRateOut: uint32, algorithm: ma_resample_algorithm): ma_resampler_config <cimport,nodecl> end

global ma_resampler: type <cimport,nodecl> = @record{

pBackend: pointer,

pBackendVTable: *ma_resampling_backend_vtable,

pBackendUserData: pointer,

format: ma_format,

channels: uint32,

sampleRateIn: uint32,

sampleRateOut: uint32,

state: union{

linear: ma_linear_resampler

},

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_resampler_get_heap_size(pConfig: *ma_resampler_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_resampler_init_preallocated(pConfig: *ma_resampler_config, pHeap: pointer, pResampler: *ma_resampler): ma_result <cimport,nodecl> end

global function ma_resampler_init(pConfig: *ma_resampler_config, pAllocationCallbacks: *ma_allocation_callbacks, pResampler: *ma_resampler): ma_result <cimport,nodecl> end

global function ma_resampler_uninit(pResampler: *ma_resampler, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_resampler_process_pcm_frames(pResampler: *ma_resampler, pFramesIn: pointer, pFrameCountIn: *uint64, pFramesOut: pointer, pFrameCountOut: *uint64): ma_result <cimport,nodecl> end

global function ma_resampler_set_rate(pResampler: *ma_resampler, sampleRateIn: uint32, sampleRateOut: uint32): ma_result <cimport,nodecl> end

global function ma_resampler_set_rate_ratio(pResampler: *ma_resampler, ratio: float32): ma_result <cimport,nodecl> end

global function ma_resampler_get_input_latency(pResampler: *ma_resampler): uint64 <cimport,nodecl> end

global function ma_resampler_get_output_latency(pResampler: *ma_resampler): uint64 <cimport,nodecl> end

global function ma_resampler_get_required_input_frame_count(pResampler: *ma_resampler, outputFrameCount: uint64, pInputFrameCount: *uint64): ma_result <cimport,nodecl> end

global function ma_resampler_get_expected_output_frame_count(pResampler: *ma_resampler, inputFrameCount: uint64, pOutputFrameCount: *uint64): ma_result <cimport,nodecl> end

global function ma_resampler_reset(pResampler: *ma_resampler): ma_result <cimport,nodecl> end

global ma_channel_conversion_path: type <cimport,nodecl,using> = @enum(cint){

ma_channel_conversion_path_unknown = 0,

ma_channel_conversion_path_passthrough = 1,

ma_channel_conversion_path_mono_out = 2,

ma_channel_conversion_path_mono_in = 3,

ma_channel_conversion_path_shuffle = 4,

ma_channel_conversion_path_weights = 5

}

global ma_mono_expansion_mode: type <cimport,nodecl,using> = @enum(cint){

ma_mono_expansion_mode_duplicate = 0,

ma_mono_expansion_mode_average = 1,

ma_mono_expansion_mode_stereo_only = 2,

ma_mono_expansion_mode_default = 0

}

global ma_channel_converter_config: type <cimport,nodecl> = @record{

format: ma_format,

channelsIn: uint32,

channelsOut: uint32,

pChannelMapIn: *ma_channel,

pChannelMapOut: *ma_channel,

mixingMode: ma_channel_mix_mode,

calculateLFEFromSpatialChannels: ma_bool32,

ppWeights: **float32

}

global function ma_channel_converter_config_init(format: ma_format, channelsIn: uint32, pChannelMapIn: *ma_channel, channelsOut: uint32, pChannelMapOut: *ma_channel, mixingMode: ma_channel_mix_mode): ma_channel_converter_config <cimport,nodecl> end

global ma_channel_converter: type <cimport,nodecl> = @record{

format: ma_format,

channelsIn: uint32,

channelsOut: uint32,

mixingMode: ma_channel_mix_mode,

conversionPath: ma_channel_conversion_path,

pChannelMapIn: *ma_channel,

pChannelMapOut: *ma_channel,

pShuffleTable: *uint8,

weights: union{

f32: **float32,

s16: **int32

},

_pHeap: pointer,

_ownsHeap: ma_bool32

}

global function ma_channel_converter_get_heap_size(pConfig: *ma_channel_converter_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_channel_converter_init_preallocated(pConfig: *ma_channel_converter_config, pHeap: pointer, pConverter: *ma_channel_converter): ma_result <cimport,nodecl> end

global function ma_channel_converter_init(pConfig: *ma_channel_converter_config, pAllocationCallbacks: *ma_allocation_callbacks, pConverter: *ma_channel_converter): ma_result <cimport,nodecl> end

global function ma_channel_converter_uninit(pConverter: *ma_channel_converter, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_channel_converter_process_pcm_frames(pConverter: *ma_channel_converter, pFramesOut: pointer, pFramesIn: pointer, frameCount: uint64): ma_result <cimport,nodecl> end

global function ma_channel_converter_get_input_channel_map(pConverter: *ma_channel_converter, pChannelMap: *ma_channel, channelMapCap: csize): ma_result <cimport,nodecl> end

global function ma_channel_converter_get_output_channel_map(pConverter: *ma_channel_converter, pChannelMap: *ma_channel, channelMapCap: csize): ma_result <cimport,nodecl> end

global ma_data_converter_config: type <cimport,nodecl> = @record{

formatIn: ma_format,

formatOut: ma_format,

channelsIn: uint32,

channelsOut: uint32,

sampleRateIn: uint32,

sampleRateOut: uint32,

pChannelMapIn: *ma_channel,

pChannelMapOut: *ma_channel,

ditherMode: ma_dither_mode,

channelMixMode: ma_channel_mix_mode,

calculateLFEFromSpatialChannels: ma_bool32,

ppChannelWeights: **float32,

allowDynamicSampleRate: ma_bool32,

resampling: ma_resampler_config

}

global function ma_data_converter_config_init_default(): ma_data_converter_config <cimport,nodecl> end

global function ma_data_converter_config_init(formatIn: ma_format, formatOut: ma_format, channelsIn: uint32, channelsOut: uint32, sampleRateIn: uint32, sampleRateOut: uint32): ma_data_converter_config <cimport,nodecl> end

global ma_data_converter_execution_path: type <cimport,nodecl,using> = @enum(cint){

ma_data_converter_execution_path_passthrough = 0,

ma_data_converter_execution_path_format_only = 1,

ma_data_converter_execution_path_channels_only = 2,

ma_data_converter_execution_path_resample_only = 3,

ma_data_converter_execution_path_resample_first = 4,

ma_data_converter_execution_path_channels_first = 5

}

global ma_data_converter: type <cimport,nodecl> = @record{

formatIn: ma_format,

formatOut: ma_format,

channelsIn: uint32,

channelsOut: uint32,

sampleRateIn: uint32,

sampleRateOut: uint32,

ditherMode: ma_dither_mode,

executionPath: ma_data_converter_execution_path,

channelConverter: ma_channel_converter,

resampler: ma_resampler,

hasPreFormatConversion: ma_bool8,

hasPostFormatConversion: ma_bool8,

hasChannelConverter: ma_bool8,

hasResampler: ma_bool8,

isPassthrough: ma_bool8,

_ownsHeap: ma_bool8,

_pHeap: pointer

}

global function ma_data_converter_get_heap_size(pConfig: *ma_data_converter_config, pHeapSizeInBytes: *csize): ma_result <cimport,nodecl> end

global function ma_data_converter_init_preallocated(pConfig: *ma_data_converter_config, pHeap: pointer, pConverter: *ma_data_converter): ma_result <cimport,nodecl> end

global function ma_data_converter_init(pConfig: *ma_data_converter_config, pAllocationCallbacks: *ma_allocation_callbacks, pConverter: *ma_data_converter): ma_result <cimport,nodecl> end

global function ma_data_converter_uninit(pConverter: *ma_data_converter, pAllocationCallbacks: *ma_allocation_callbacks): void <cimport,nodecl> end

global function ma_data_converter_process_pcm_frames(pConverter: *ma_data_converter, pFramesIn: pointer, pFrameCountIn: *uint64, pFramesOut: pointer, pFrameCountOut: *uint64): ma_result <cimport,nodecl> end

global function ma_data_converter_set_rate(pConverter: *ma_data_converter, sampleRateIn: uint32, sampleRateOut: uint32): ma_result <cimport,nodecl> end

global function ma_data_converter_set_rate_ratio(pConverter: *ma_data_converter, ratioInOut: float32): ma_result <cimport,nodecl> end

global function ma_data_converter_get_input_latency(pConverter: *ma_data_converter): uint64 <cimport,nodecl> end

global function ma_data_converter_get_output_latency(pConverter: *ma_data_converter): uint64 <cimport,nodecl> end

global function ma_data_converter_get_required_input_frame_count(pConverter: *ma_data_converter, outputFrameCount: uint64, pInputFrameCount: *uint64): ma_result <cimport,nodecl> end

global function ma_data_converter_get_expected_output_frame_count(pConverter: *ma_data_converter, inputFrameCount: uint64, pOutputFrameCount: *uint64): ma_result <cimport,nodecl> end

global function ma_data_converter_get_input_channel_map(pConverter: *ma_data_converter, pChannelMap: *ma_channel, channelMapCap: csize): ma_result <cimport,nodecl> end

global function ma_data_converter_get_output_channel_map(pConverter: *ma_data_converter, pChannelMap: *ma_channel, channelMapCap: csize): ma_result <cimport,nodecl> end

global function ma_data_converter_reset(pConverter: *ma_data_converter): ma_result <cimport,nodecl> end

global function ma_pcm_u8_to_s16(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_u8_to_s24(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_u8_to_s32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_u8_to_f32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s16_to_u8(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s16_to_s24(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s16_to_s32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s16_to_f32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s24_to_u8(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s24_to_s16(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s24_to_s32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s24_to_f32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s32_to_u8(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s32_to_s16(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s32_to_s24(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_s32_to_f32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_f32_to_u8(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_f32_to_s16(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_f32_to_s24(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_f32_to_s32(pOut: pointer, pIn: pointer, count: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_pcm_convert(pOut: pointer, formatOut: ma_format, pIn: pointer, formatIn: ma_format, sampleCount: uint64, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_convert_pcm_frames_format(pOut: pointer, formatOut: ma_format, pIn: pointer, formatIn: ma_format, frameCount: uint64, channels: uint32, ditherMode: ma_dither_mode): void <cimport,nodecl> end

global function ma_deinterleave_pcm_frames(format: ma_format, channels: uint32, frameCount: uint64, pInterleavedPCMFrames: pointer, ppDeinterleavedPCMFrames: *pointer): void <cimport,nodecl> end

global function ma_interleave_pcm_frames(format: ma_format, channels: uint32, frameCount: uint64, ppDeinterleavedPCMFrames: *pointer, pInterleavedPCMFrames: pointer): void <cimport,nodecl> end

global function ma_channel_map_get_channel(pChannelMap: *ma_channel, channelCount: uint32, channelIndex: uint32): ma_channel <cimport,nodecl> end

global function ma_channel_map_init_blank(pChannelMap: *ma_channel, channels: uint32): void <cimport,nodecl> end

global function ma_channel_map_init_standard(standardChannelMap: ma_standard_channel_map, pChannelMap: *ma_channel, channelMapCap: csize, channels: uint32): void <cimport,nodecl> end

global function ma_channel_map_copy(pOut: *ma_channel, pIn: *ma_channel, channels: uint32): void <cimport,nodecl> end

global function ma_channel_map_copy_or_default(pOut: *ma_channel, channelMapCapOut: csize, pIn: *ma_channel, channels: uint32): void <cimport,nodecl> end

global function ma_channel_map_is_valid(pChannelMap: *ma_channel, channels: uint32): ma_bool32 <cimport,nodecl> end

global function ma_channel_map_is_equal(pChannelMapA: *ma_channel, pChannelMapB: *ma_channel, channels: uint32): ma_bool32 <cimport,nodecl> end

global function ma_channel_map_is_blank(pChannelMap: *ma_channel, channels: uint32): ma_bool32 <cimport,nodecl> end

global function ma_channel_map_contains_channel_position(channels: uint32, pChannelMap: *ma_channel, channelPosition: ma_channel): ma_bool32 <cimport,nodecl> end

global function ma_channel_map_find_channel_position(channels: uint32, pChannelMap: *ma_channel, channelPosition: ma_channel, pChannelIndex: *uint32): ma_bool32 <cimport,nodecl> end

global function ma_channel_map_to_string(pChannelMap: *ma_channel, channels: uint32, pBufferOut: cstring, bufferCap: csize): csize <cimport,nodecl> end

global function ma_channel_position_to_string(channel: ma_channel): cstring <cimport,nodecl> end

global function ma_convert_frames(pOut: pointer, frameCountOut: uint64, formatOut: ma_format, channelsOut: uint32, sampleRateOut: uint32, pIn: pointer, frameCountIn: uint64, formatIn: ma_format, channelsIn: uint32, sampleRateIn: uint32): uint64 <cimport,nodecl> end

global function ma_convert_frames_ex(pOut: pointer, frameCountOut: uint64, pIn: pointer, frameCountIn: uint64, pConfig: *ma_data_converter_config): uint64 <cimport,nodecl> end

global ma_data_source_vtable: type <cimport,nodecl> = @record{

onRead: function(pointer, pointer, uint64, *uint64): ma_result,

onSeek: function(pointer, uint64): ma_result,

onGetDataFormat: function(pointer, *ma_format, *uint32, *uint32, *ma_channel, csize): ma_result,

onGetCursor: function(pointer, *uint64): ma_result,

onGetLength: function(pointer, *uint64): ma_result,

onSetLooping: function(pointer, ma_bool32): ma_result,