package vendor:miniaudio

Source

IMMNotificationClient :: struct {
	lpVtbl:  rawptr,
	counter: u32,
	pDevice: ^device,
}

aaudio_allowed_capture_policy :: enum i32 {
	default = 0, // Leaves the allowed capture policy unset.
	all,         // AAUDIO_ALLOW_CAPTURE_BY_ALL
	system,      // AAUDIO_ALLOW_CAPTURE_BY_SYSTEM
	none,        // AAUDIO_ALLOW_CAPTURE_BY_NONE
}

aaudio_content_type :: enum i32 {
	default      = 0, // Leaves the content type unset.
	speech,           // AAUDIO_CONTENT_TYPE_SPEECH
	music,            // AAUDIO_CONTENT_TYPE_MUSIC
	movie,            // AAUDIO_CONTENT_TYPE_MOVIE
	sonification,     // AAUDIO_CONTENT_TYPE_SONIFICATION
}

aaudio_input_preset :: enum i32 {
	default             = 0, // Leaves the input preset unset.
	generic,                 // AAUDIO_INPUT_PRESET_GENERIC
	camcorder,               // AAUDIO_INPUT_PRESET_CAMCORDER
	voice_recognition,       // AAUDIO_INPUT_PRESET_VOICE_RECOGNITION
	voice_communication,     // AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION
	unprocessed,             // AAUDIO_INPUT_PRESET_UNPROCESSED
	voice_performance,       // AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE
}

aaudio_usage :: enum i32 {
	default                        = 0, // Leaves the usage type unset.
	media,                              // AAUDIO_USAGE_MEDIA
	voice_communication,                // AAUDIO_USAGE_VOICE_COMMUNICATION
	voice_communication_signalling,     // AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING
	alarm,                              // AAUDIO_USAGE_ALARM
	notification,                       // AAUDIO_USAGE_NOTIFICATION
	notification_ringtone,              // AAUDIO_USAGE_NOTIFICATION_RINGTONE
	notification_event,                 // AAUDIO_USAGE_NOTIFICATION_EVENT
	assistance_accessibility,           // AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY
	assistance_navigation_guidance,     // AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE
	assistance_sonification,            // AAUDIO_USAGE_ASSISTANCE_SONIFICATION
	game,                               // AAUDIO_USAGE_GAME
	assitant,                           // AAUDIO_USAGE_ASSISTANT
	emergency,                          // AAUDIO_SYSTEM_USAGE_EMERGENCY
	safety,                             // AAUDIO_SYSTEM_USAGE_SAFETY
	vehicle_status,                     // AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS
	announcement,                       // AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT
}

allocation_callbacks :: struct {
	pUserData: rawptr,
	onMalloc:  proc "c" (sz: uint, pUserData: rawptr) -> rawptr,
	onRealloc: proc "c" (p: rawptr, sz: uint, pUserData: rawptr) -> rawptr,
	onFree:    proc "c" (p: rawptr, pUserData: rawptr),
}

async_notification :: struct {}

async_notification_callbacks :: struct {
	onSignal: proc "c" (pNotification: ^async_notification),
}

async_notification_event :: struct {
	cb: async_notification_callbacks,
	e:  event,
}

async_notification_poll :: struct {
	cb:        async_notification_callbacks,
	signalled: b32,
}

atomic_vec3f :: struct {
	v:    vec3f,
	lock: spinlock,
}

attenuation_model :: enum i32 {
	none,        // No distance attenuation and no spatialization.
	inverse,     // Equivalent to OpenAL's AL_INVERSE_DISTANCE_CLAMPED.
	linear,      // Linear attenuation. Equivalent to OpenAL's AL_LINEAR_DISTANCE_CLAMPED.
	exponential, // Exponential attenuation. Equivalent to OpenAL's AL_EXPONENT_DISTANCE_CLAMPED.
}

audio_buffer :: struct {
	ref:                 audio_buffer_ref,
	allocationCallbacks: allocation_callbacks,
	ownsData:            b32,
	// Used to control whether or not miniaudio owns the data buffer. If set to true, pData will be freed in ma_audio_buffer_uninit(). 
	_pExtraData:         [1]u8,
}

audio_buffer_config :: struct {
	format:              format,
	channels:            u32,
	sampleRate:          u32,
	sizeInFrames:        u64,
	pData:               rawptr,
	// If set to NULL, will allocate a block of memory for you. 
	allocationCallbacks: allocation_callbacks,
}

audio_buffer_ref :: struct {
	ds:           data_source_base,
	format:       format,
	channels:     u32,
	sampleRate:   u32,
	cursor:       u64,
	sizeInFrames: u64,
	pData:        rawptr,
}

backend :: enum i32 {
	wasapi, 
	dsound, 
	winmm, 
	coreaudio, 
	sndio, 
	audio4, 
	oss, 
	pulseaudio, 
	alsa, 
	jack, 
	aaudio, 
	opensl, 
	webaudio, 
	custom,     // <-- Custom backend, with callbacks defined by the context config.
	null,       // <-- Must always be the last item. Lowest priority, and used as the terminator for backend enumeration.
}

backend_callbacks :: struct {
	onContextInit:             proc "c" (pContext: ^context_type, pConfig: ^context_config, pCallbacks: ^backend_callbacks) -> result,
	onContextUninit:           proc "c" (pContext: ^context_type) -> result,
	onContextEnumerateDevices: proc "c" (pContext: ^context_type, callback: enum_devices_callback_proc, pUserData: rawptr) -> result,
	onContextGetDeviceInfo:    proc "c" (pContext: ^context_type, deviceType: device_type, pDeviceID: ^device_id, pDeviceInfo: ^device_info) -> result,
	onDeviceInit:              proc "c" (pDevice: ^device, pConfig: ^device_config, pDescriptorPlayback, pDescriptorCapture: ^device_descriptor) -> result,
	onDeviceUninit:            proc "c" (pDevice: ^device) -> result,
	onDeviceStart:             proc "c" (pDevice: ^device) -> result,
	onDeviceStop:              proc "c" (pDevice: ^device) -> result,
	onDeviceRead:              proc "c" (pDevice: ^device, pFrames: rawptr, frameCount: u32, pFramesRead: ^u32) -> result,
	onDeviceWrite:             proc "c" (pDevice: ^device, pFrames: rawptr, frameCount: u32, pFramesWritten: ^u32) -> result,
	onDeviceDataLoop:          proc "c" (pDevice: ^device) -> result,
	onDeviceDataLoopWakeup:    proc "c" (pDevice: ^device) -> result,
	onDeviceGetInfo:           proc "c" (pDevice: ^device, type: device_type, pDeviceInfo: ^device_info) -> result,
}

biquad :: struct {
	format:    format,
	channels:  u32,
	b0:        biquad_coefficient,
	b1:        biquad_coefficient,
	b2:        biquad_coefficient,
	a1:        biquad_coefficient,
	a2:        biquad_coefficient,
	pR1:       ^biquad_coefficient,
	pR2:       ^biquad_coefficient,
	// Memory management. 
	_pHeap:    rawptr,
	_ownsHeap: b32,
}

biquad_coefficient :: struct #raw_union {
	f32: f32,
	s32: i32,
}

biquad_config :: struct {
	format:   format,
	channels: u32,
	b0:       f64,
	b1:       f64,
	b2:       f64,
	a0:       f64,
	a1:       f64,
	a2:       f64,
}

biquad_node :: struct {
	baseNode: node_base,
	biquad:   biquad,
}

biquad_node_config :: struct {
	nodeConfig: node_config,
	biquad:     biquad_config,
}

bpf :: struct {
	format:    format,
	channels:  u32,
	bpf2Count: u32,
	pBPF2:     ^bpf2,
	// Memory management. 
	_pHeap:    rawptr,
	_ownsHeap: b32,
}

bpf2 :: struct {
	bq: biquad,
}

bpf2_config :: struct {
	format:          format,
	channels:        u32,
	sampleRate:      u32,
	cutoffFrequency: f64,
	q:               f64,
}

bpf_config :: struct {
	format:          format,
	channels:        u32,
	sampleRate:      u32,
	cutoffFrequency: f64,
	order:           u32,
}

bpf_node :: struct {
	baseNode: node_base,
	bpf:      bpf,
}

bpf_node_config :: struct {
	nodeConfig: node_config,
	bpf:        bpf_config,
}

channel :: enum u8 {
	NONE               = 0, 
	MONO               = 1, 
	FRONT_LEFT         = 2, 
	FRONT_RIGHT        = 3, 
	FRONT_CENTER       = 4, 
	LFE                = 5, 
	BACK_LEFT          = 6, 
	BACK_RIGHT         = 7, 
	FRONT_LEFT_CENTER  = 8, 
	FRONT_RIGHT_CENTER = 9, 
	BACK_CENTER        = 10, 
	SIDE_LEFT          = 11, 
	SIDE_RIGHT         = 12, 
	TOP_CENTER         = 13, 
	TOP_FRONT_LEFT     = 14, 
	TOP_FRONT_CENTER   = 15, 
	TOP_FRONT_RIGHT    = 16, 
	TOP_BACK_LEFT      = 17, 
	TOP_BACK_CENTER    = 18, 
	TOP_BACK_RIGHT     = 19, 
	AUX_0              = 20, 
	AUX_1              = 21, 
	AUX_2              = 22, 
	AUX_3              = 23, 
	AUX_4              = 24, 
	AUX_5              = 25, 
	AUX_6              = 26, 
	AUX_7              = 27, 
	AUX_8              = 28, 
	AUX_9              = 29, 
	AUX_10             = 30, 
	AUX_11             = 31, 
	AUX_12             = 32, 
	AUX_13             = 33, 
	AUX_14             = 34, 
	AUX_15             = 35, 
	AUX_16             = 36, 
	AUX_17             = 37, 
	AUX_18             = 38, 
	AUX_19             = 39, 
	AUX_20             = 40, 
	AUX_21             = 41, 
	AUX_22             = 42, 
	AUX_23             = 43, 
	AUX_24             = 44, 
	AUX_25             = 45, 
	AUX_26             = 46, 
	AUX_27             = 47, 
	AUX_28             = 48, 
	AUX_29             = 49, 
	AUX_30             = 50, 
	AUX_31             = 51, 
	LEFT               = 2, 
	RIGHT              = 3, 
	POSITION_COUNT     = 52, 
}

channel_conversion_path :: enum i32 {
	unknown, 
	passthrough, 
	mono_out,    // Converting to mono.
	mono_in,     // Converting from mono.
	shuffle,     // Simple shuffle. Will use this when all channels are present in both input and output channel maps, but just in a different order.
	weights,     // Blended based on weights.
}

channel_converter :: struct {
	format:         format,
	channelsIn:     u32,
	channelsOut:    u32,
	mixingMode:     channel_mix_mode,
	conversionPath: channel_conversion_path,
	pChannelMapIn:  [^]channel,
	pChannelMapOut: [^]channel,
	pShuffleTable:  [^]u8,
	weights:        struct #raw_union {
		// [in][out] 
		f32: ^[^]f32,
		s16: ^[^]i32,
	},
	// Memory management. 
	_pHeap:         rawptr,
	_ownsHeap:      b32,
}

channel_converter_config :: struct {
	format:                          format,
	channelsIn:                      u32,
	channelsOut:                     u32,
	pChannelMapIn:                   [^]channel,
	pChannelMapOut:                  [^]channel,
	mixingMode:                      channel_mix_mode,
	calculateLFEFromSpatialChannels: b32,
	// When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. 
	ppWeights:                       ^[^]f32,
}

channel_mix_mode :: enum i32 {
	rectangular    = 0, // Simple averaging based on the plane(s) the channel is sitting on.
	simple,             // Drop excess channels; zeroed out extra channels.
	custom_weights,     // Use custom weights specified in ma_channel_converter_config.
	default        = 0, 
}

context_command__wasapi :: struct {
	code:   i32,
	pEvent: ^event,
	// This will be signalled when the event is complete. 
	data:   struct #raw_union {
		quit:               struct {
			_unused: i32,
		},
		createAudioClient:  struct {
			deviceType:           device_type,
			pAudioClient:         rawptr,
			ppAudioClientService: ^rawptr,
			pResult:              ^result,
		},
		releaseAudioClient: struct {
			pDevice:    ^device,
			deviceType: device_type,
		},
	},
}

context_config :: struct {
	pLog:                ^log,
	threadPriority:      thread_priority,
	threadStackSize:     uint,
	pUserData:           rawptr,
	allocationCallbacks: allocation_callbacks,
	alsa:                struct {
		useVerboseDeviceEnumeration: b32,
	},
	pulse:               struct {
		pApplicationName: cstring,
		pServerName:      cstring,
		tryAutoSpawn:     b32,
	},
	coreaudio:           struct {
		sessionCategory:          ios_session_category,
		sessionCategoryOptions:   u32,
		noAudioSessionActivate:   b32,
		// iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:true] on initialization. 
		noAudioSessionDeactivate: b32,
	},
	jack:                struct {
		pClientName:    cstring,
		tryStartServer: b32,
	},
	custom:              backend_callbacks,
}

context_type :: struct {
	callbacks:               backend_callbacks,
	backend:                 backend,
	// DirectSound, ALSA, etc. 
	pLog:                    ^log,
	log:                     log,
	// Only used if the log is owned by the context. The pLog member will be set to &log in this case. 
	threadPriority:          thread_priority,
	threadStackSize:         uint,
	pUserData:               rawptr,
	allocationCallbacks:     allocation_callbacks,
	deviceEnumLock:          mutex,
	// Used to make ma_context_get_devices() thread safe. 
	deviceInfoLock:          mutex,
	// Used to make ma_context_get_device_info() thread safe. 
	deviceInfoCapacity:      u32,
	// Total capacity of pDeviceInfos. 
	playbackDeviceInfoCount: u32,
	captureDeviceInfoCount:  u32,
	pDeviceInfos:            [^]device_info,
	// Playback devices first, then capture. 
	using _:                 struct #raw_union {
		wasapi:       struct {
			commandThread:                   thread,
			commandLock:                     mutex,
			commandSem:                      semaphore,
			commandIndex:                    u32,
			commandCount:                    u32,
			commands:                        [4]context_command__wasapi,
			hAvrt:                           handle,
			AvSetMmThreadCharacteristicsA:   proc "stdcall" (),
			AvRevertMmThreadCharacteristics: proc "stdcall" (),
			hMMDevapi:                       handle,
			ActivateAudioInterfaceAsync:     proc "stdcall" (),
		},
		dsound:       struct {
			hDSoundDLL:                   handle,
			DirectSoundCreate:            proc "stdcall" (),
			DirectSoundEnumerateA:        proc "stdcall" (),
			DirectSoundCaptureCreate:     proc "stdcall" (),
			DirectSoundCaptureEnumerateA: proc "stdcall" (),
		},
		winmm:        struct {
			hWinMM:                 handle,
			waveOutGetNumDevs:      proc "stdcall" (),
			waveOutGetDevCapsA:     proc "stdcall" (),
			waveOutOpen:            proc "stdcall" (),
			waveOutClose:           proc "stdcall" (),
			waveOutPrepareHeader:   proc "stdcall" (),
			waveOutUnprepareHeader: proc "stdcall" (),
			waveOutWrite:           proc "stdcall" (),
			waveOutReset:           proc "stdcall" (),
			waveInGetNumDevs:       proc "stdcall" (),
			waveInGetDevCapsA:      proc "stdcall" (),
			waveInOpen:             proc "stdcall" (),
			waveInClose:            proc "stdcall" (),
			waveInPrepareHeader:    proc "stdcall" (),
			waveInUnprepareHeader:  proc "stdcall" (),
			waveInAddBuffer:        proc "stdcall" (),
			waveInStart:            proc "stdcall" (),
			waveInReset:            proc "stdcall" (),
		},
		alsa:         struct {},
		pulse:        struct {},
		jack:         struct {
			jackSO:                        handle,
			jack_client_open:              proc "stdcall" (),
			jack_client_close:             proc "stdcall" (),
			jack_client_name_size:         proc "stdcall" (),
			jack_set_process_callback:     proc "stdcall" (),
			jack_set_buffer_size_callback: proc "stdcall" (),
			jack_on_shutdown:              proc "stdcall" (),
			jack_get_sample_rate:          proc "stdcall" (),
			jack_get_buffer_size:          proc "stdcall" (),
			jack_get_ports:                proc "stdcall" (),
			jack_activate:                 proc "stdcall" (),
			jack_deactivate:               proc "stdcall" (),
			jack_connect:                  proc "stdcall" (),
			jack_port_register:            proc "stdcall" (),
			jack_port_name:                proc "stdcall" (),
			jack_port_get_buffer:          proc "stdcall" (),
			jack_free:                     proc "stdcall" (),
			pClientName:                   cstring,
			tryStartServer:                b32,
		},
		coreaudio:    struct {},
		sndio:        struct {},
		audio4:       struct {},
		oss:          struct {},
		aaudio:       struct {},
		opensl:       struct {},
		webaudio:     struct {},
		null_backend: struct {
			_unused: i32,
		},
	},
	using _:                 struct #raw_union {
		win32:   struct {
			hOle32DLL:           handle,
			CoInitialize:        proc "stdcall" (),
			CoInitializeEx:      proc "stdcall" (),
			CoUninitialize:      proc "stdcall" (),
			CoCreateInstance:    proc "stdcall" (),
			CoTaskMemFree:       proc "stdcall" (),
			PropVariantClear:    proc "stdcall" (),
			StringFromGUID2:     proc "stdcall" (),
			hUser32DLL:          handle,
			GetForegroundWindow: proc "stdcall" (),
			GetDesktopWindow:    proc "stdcall" (),
			hAdvapi32DLL:        handle,
			RegOpenKeyExA:       proc "stdcall" (),
			RegCloseKey:         proc "stdcall" (),
			RegQueryValueExA:    proc "stdcall" (),
			CoInitializeResult:  i32,
		},
		posix:   struct {},
		_unused: i32,
	},
}

data_converter :: struct {
	formatIn:                format,
	formatOut:               format,
	channelsIn:              u32,
	channelsOut:             u32,
	sampleRateIn:            u32,
	sampleRateOut:           u32,
	ditherMode:              dither_mode,
	executionPath:           data_converter_execution_path,
	// The execution path the data converter will follow when processing. 
	channelConverter:        channel_converter,
	resampler:               resampler,
	hasPreFormatConversion:  b8,
	hasPostFormatConversion: b8,
	hasChannelConverter:     b8,
	hasResampler:            b8,
	isPassthrough:           b8,
	// Memory management. 
	_ownsHeap:               b8,
	_pHeap:                  rawptr,
}

data_converter_config :: struct {
	formatIn:                        format,
	formatOut:                       format,
	channelsIn:                      u32,
	channelsOut:                     u32,
	sampleRateIn:                    u32,
	sampleRateOut:                   u32,
	pChannelMapIn:                   [^]channel,
	pChannelMapOut:                  [^]channel,
	ditherMode:                      dither_mode,
	channelMixMode:                  channel_mix_mode,
	calculateLFEFromSpatialChannels: b32,
	// When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. 
	ppChannelWeights:                ^[^]f32,
	// [in][out]. Only used when channelMixMode is set to ma_channel_mix_mode_custom_weights. 
	allowDynamicSampleRate:          b32,
	resampling:                      resampler_config,
}

data_converter_execution_path :: enum i32 {
	passthrough,    // No conversion.
	format_only,    // Only format conversion.
	channels_only,  // Only channel conversion.
	resample_only,  // Only resampling.
	resample_first, // All conversions, but resample as the first step.
	channels_first, // All conversions, but channels as the first step.
}

data_source :: struct {}

data_source_base :: struct {
	vtable:           ^data_source_vtable,
	rangeBegInFrames: u64,
	rangeEndInFrames: u64,
	// Set to -1 for unranged (default). 
	loopBegInFrames:  u64,
	// Relative to rangeBegInFrames. 
	loopEndInFrames:  u64,
	// Relative to rangeBegInFrames. Set to -1 for the end of the range. 
	pCurrent:         ^data_source,
	// When non-NULL, the data source being initialized will act as a proxy and will route all operations to pCurrent. Used in conjunction with pNext/onGetNext for seamless chaining. 
	pNext:            ^data_source,
	// When set to NULL, onGetNext will be used. 
	onGetNext:        data_source_get_next_proc,
	// Will be used when pNext is NULL. If both are NULL, no next will be used. 
	isLooping:        b32,
}

data_source_config :: struct {
	vtable: ^data_source_vtable,
}

data_source_get_next_proc :: proc "c" (pDataSource: ^data_source) -> ^data_source

data_source_node :: struct {
	base:        node_base,
	pDataSource: ^data_source,
}

data_source_node_config :: struct {
	nodeConfig:  node_config,
	pDataSource: ^data_source,
}

data_source_vtable :: struct {
	onRead:          proc "c" (pDataSource: ^data_source, pFramesOut: rawptr, frameCount: u64, pFramesRead: ^u64) -> result,
	onSeek:          proc "c" (pDataSource: ^data_source, frameIndex: u64) -> result,
	onGetDataFormat: proc "c" (pDataSource: ^data_source, pFormat: ^format, pChannels: ^u32, pSampleRate: ^u32, pChannelMap: [^]channel, channelMapCap: uint) -> result,
	onGetCursor:     proc "c" (pDataSource: ^data_source, pCursor: ^u64) -> result,
	onGetLength:     proc "c" (pDataSource: ^data_source, pLength: ^u64) -> result,
	onSetLooping:    proc "c" (pDataSource: ^data_source, isLooping: b32) -> result,
	flags:           u32,
}

decoder :: struct {
	ds:                     data_source_base,
	pBackend:               ^data_source,
	// The decoding backend we'll be pulling data from. 
	pBackendVTable:         ^decoding_backend_vtable,
	// The vtable for the decoding backend. This needs to be stored so we can access the onUninit() callback. 
	pBackendUserData:       rawptr,
	onRead:                 decoder_read_proc,
	onSeek:                 decoder_seek_proc,
	onTell:                 decoder_tell_proc,
	pUserData:              rawptr,
	readPointerInPCMFrames: u64,
	// In output sample rate. Used for keeping track of how many frames are available for decoding. 
	outputFormat:           format,
	outputChannels:         u32,
	outputSampleRate:       u32,
	converter:              data_converter,
	// <-- Data conversion is achieved by running frames through this. 
	pInputCache:            rawptr,
	// In input format. Can be null if it's not needed. 
	inputCacheCap:          u64,
	// The capacity of the input cache. 
	inputCacheConsumed:     u64,
	// The number of frames that have been consumed in the cache. Used for determining the next valid frame. 
	inputCacheRemaining:    u64,
	// The number of valid frames remaining in the cahce. 
	allocationCallbacks:    allocation_callbacks,
	data:                   struct #raw_union {
		vfs:    struct {
			pVFS: ^vfs,
			file: vfs_file,
		},
		memory: struct {
			pData:          [^]u8,
			dataSize:       uint,
			currentReadPos: uint,
		},
	},
}

decoder_config :: struct {
	format:                 format,
	// Set to 0 or ma_format_unknown to use the stream's internal format. 
	channels:               u32,
	// Set to 0 to use the stream's internal channels. 
	sampleRate:             u32,
	// Set to 0 to use the stream's internal sample rate. 
	channelMap:             [^]channel,
	channelMixMode:         channel_mix_mode,
	ditherMode:             dither_mode,
	resampling:             resampler_config,
	allocationCallbacks:    allocation_callbacks,
	encodingFormat:         encoding_format,
	seekPointCount:         u32,
	// When set to > 0, specifies the number of seek points to use for the generation of a seek table. Not all decoding backends support this. 
	ppCustomBackendVTables: ^[^]decoding_backend_vtable,
	customBackendCount:     u32,
	pCustomBackendUserData: rawptr,
}

decoder_read_proc :: proc "c" (pDecoder: ^decoder, pBufferOut: rawptr, bytesToRead: uint, pBytesRead: ^uint) -> result

decoder_seek_proc :: proc "c" (pDecoder: ^decoder, byteOffset: i64, origin: seek_origin) -> result

decoder_tell_proc :: proc "c" (pDecoder: ^decoder, pCursor: ^i64) -> result

decoding_backend_config :: struct {
	preferredFormat: format,
	seekPointCount:  u32,
}

decoding_backend_vtable :: struct {
	onInit:       proc "c" (pUserData: rawptr, onRead: decoder_read_proc, onSeek: decoder_seek_proc, onTell: decoder_tell_proc, pReadSeekTellUserData: rawptr, pConfig: ^decoding_backend_config, pAllocationCallbacks: ^allocation_callbacks, ppBackend: ^^data_source) -> result,
	onInitFile:   proc "c" (pUserData: rawptr, pFilePath: cstring, pConfig: ^decoding_backend_config, pAllocationCallbacks: ^allocation_callbacks, ppBackend: ^^data_source) -> result,
	// Optional. 
	onInitFileW:  proc "c" (pUserData: rawptr, pFilePath: [^]u16, pConfig: ^decoding_backend_config, pAllocationCallbacks: ^allocation_callbacks, ppBackend: ^^data_source) -> result,
	// Optional. 
	onInitMemory: proc "c" (pUserData: rawptr, pData: rawptr, dataSize: uint, pConfig: ^decoding_backend_config, pAllocationCallbacks: ^allocation_callbacks, ppBackend: ^^data_source) -> result,
	// Optional. 
	onUninit:     proc "c" (pUserData: rawptr, pBackend: ^data_source, pAllocationCallbacks: ^allocation_callbacks),
}

default_vfs :: struct {
	cb:                  vfs_callbacks,
	allocationCallbacks: allocation_callbacks,
}

delay :: struct {
	config:             delay_config,
	cursor:             u32,
	// Feedback is written to this cursor. Always equal or in front of the read cursor. 
	bufferSizeInFrames: u32,
	pBuffer:            [^]f32,
}

delay_config :: struct {
	channels:      u32,
	sampleRate:    u32,
	delayInFrames: u32,
	delayStart:    b32,
	// Set to true to delay the start of the output; false otherwise. 
	wet:           f32,
	// 0..1. Default = 1. 
	dry:           f32,
	// 0..1. Default = 1. 
	decay:         f32,
}

delay_node :: struct {
	baseNode: node_base,
	delay:    delay,
}

delay_node_config :: struct {
	nodeConfig: node_config,
	delay:      delay_config,
}

device :: struct {
	pContext:                  ^context_type,
	type:                      device_type,
	sampleRate:                u32,
	state:                     u32,
	// atomic
	// The state of the device is variable and can change at any time on any thread. Must be used atomically. 
	onData:                    device_data_proc,
	// Set once at initialization time and should not be changed after. 
	onNotification:            device_notification_proc,
	// Set once at initialization time and should not be changed after. 
	onStop:                    stop_proc,
	// DEPRECATED. Use the notification callback instead. Set once at initialization time and should not be changed after. 
	pUserData:                 rawptr,
	// Application defined data. 
	startStopLock:             mutex,
	wakeupEvent:               event,
	startEvent:                event,
	stopEvent:                 event,
	device_thread:             thread,
	workResult:                result,
	// This is set by the worker thread after it's finished doing a job. 
	isOwnerOfContext:          b8,
	// When set to true, uninitializing the device will also uninitialize the context. Set to true when NULL is passed into ma_device_init(). 
	noPreSilencedOutputBuffer: b8,
	noClip:                    b8,
	noDisableDenormals:        b8,
	noFixedSizedCallback:      b8,
	masterVolumeFactor:        f32,
	// atomic
	// Linear 0..1. Can be read and written simultaneously by different threads. Must be used atomically. 
	duplexRB:                  duplex_rb,
	// Intermediary buffer for duplex device on asynchronous backends. 
	resampling:                struct {
		algorithm:        resample_algorithm,
		pBackendVTable:   ^resampling_backend_vtable,
		pBackendUserData: rawptr,
		linear:           struct {
			lpfOrder: u32,
		},
	},
	playback:                  struct {
		pID:                             ^device_id,
		// Set to NULL if using default ID, otherwise set to the address of "id". 
		id:                              device_id,
		// If using an explicit device, will be set to a copy of the ID used for initialization. Otherwise cleared to 0. 
		name:                            [256]u8,
		// Maybe temporary. Likely to be replaced with a query API. 
		shareMode:                       share_mode,
		// Set to whatever was passed in when the device was initialized. 
		playback_format:                 format,
		channels:                        u32,
		channelMap:                      [254]channel,
		internalFormat:                  format,
		internalChannels:                u32,
		internalSampleRate:              u32,
		internalChannelMap:              [254]channel,
		internalPeriodSizeInFrames:      u32,
		internalPeriods:                 u32,
		channelMixMode:                  channel_mix_mode,
		calculateLFEFromSpatialChannels: b32,
		converter:                       data_converter,
		pIntermediaryBuffer:             rawptr,
		// For implementing fixed sized buffer callbacks. Will be null if using variable sized callbacks. 
		intermediaryBufferCap:           u32,
		intermediaryBufferLen:           u32,
		// How many valid frames are sitting in the intermediary buffer. 
		pInputCache:                     rawptr,
		// In external format. Can be null. 
		inputCacheCap:                   u64,
		inputCacheConsumed:              u64,
		inputCacheRemaining:             u64,
	},
	capture:                   struct {
		pID:                             ^device_id,
		// Set to NULL if using default ID, otherwise set to the address of "id". 
		id:                              device_id,
		// If using an explicit device, will be set to a copy of the ID used for initialization. Otherwise cleared to 0. 
		name:                            [256]u8,
		// Maybe temporary. Likely to be replaced with a query API. 
		shareMode:                       share_mode,
		// Set to whatever was passed in when the device was initialized. 
		capture_format:                  format,
		channels:                        u32,
		channelMap:                      [254]channel,
		internalFormat:                  format,
		internalChannels:                u32,
		internalSampleRate:              u32,
		internalChannelMap:              [254]channel,
		internalPeriodSizeInFrames:      u32,
		internalPeriods:                 u32,
		channelMixMode:                  channel_mix_mode,
		calculateLFEFromSpatialChannels: b32,
		converter:                       data_converter,
		pIntermediaryBuffer:             rawptr,
		// For implementing fixed sized buffer callbacks. Will be null if using variable sized callbacks. 
		intermediaryBufferCap:           u32,
		intermediaryBufferLen:           u32,
	},
	using _:                   struct #raw_union {
		wasapi:      struct {
			pAudioClientPlayback:             rawptr,
			pAudioClientCapture:              rawptr,
			pRenderClient:                    rawptr,
			pCaptureClient:                   rawptr,
			pDeviceEnumerator:                rawptr,
			// Used for IMMNotificationClient notifications. Required for detecting default device changes. 
			notificationClient:               IMMNotificationClient,
			hEventPlayback:                   handle,
			hEventCapture:                    handle,
			// Auto reset. Initialized to unsignaled. 
			actualPeriodSizeInFramesPlayback: u32,
			// Value from GetBufferSize(). internalPeriodSizeInFrames is not set to the _actual_ buffer size when low-latency shared mode is being used due to the way the IAudioClient3 API works. 
			actualPeriodSizeInFramesCapture:  u32,
			originalPeriodSizeInFrames:       u32,
			originalPeriodSizeInMilliseconds: u32,
			originalPeriods:                  u32,
			originalPerformanceProfile:       performance_profile,
			periodSizeInFramesPlayback:       u32,
			periodSizeInFramesCapture:        u32,
			pMappedBufferCapture:             rawptr,
			mappedBufferCaptureCap:           u32,
			mappedBufferCaptureLen:           u32,
			pMappedBufferPlayback:            rawptr,
			mappedBufferPlaybackCap:          u32,
			mappedBufferPlaybackLen:          u32,
			isStartedCapture:                 b32,
			// atomic
			// Can be read and written simultaneously across different threads. Must be used atomically, and must be 32-bit. 
			isStartedPlayback:                b32,
			// atomic
			// Can be read and written simultaneously across different threads. Must be used atomically, and must be 32-bit. 
			loopbackProcessID:                u32,
			loopbackProcessExclude:           b8,
			noAutoConvertSRC:                 b8,
			// When set to true, disables the use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM. 
			noDefaultQualitySRC:              b8,
			// When set to true, disables the use of AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY. 
			noHardwareOffloading:             b8,
			allowCaptureAutoStreamRouting:    b8,
			allowPlaybackAutoStreamRouting:   b8,
			isDetachedPlayback:               b8,
			isDetachedCapture:                b8,
			usage:                            wasapi_usage,
			hAvrtHandle:                      rawptr,
			rerouteLock:                      mutex,
		},
		dsound:      struct {
			pPlayback:              rawptr,
			pPlaybackPrimaryBuffer: rawptr,
			pPlaybackBuffer:        rawptr,
			pCapture:               rawptr,
			pCaptureBuffer:         rawptr,
		},
		winmm:       struct {
			hDevicePlayback:              handle,
			hDeviceCapture:               handle,
			hEventPlayback:               handle,
			hEventCapture:                handle,
			fragmentSizeInFrames:         u32,
			iNextHeaderPlayback:          u32,
			// [0,periods). Used as an index into pWAVEHDRPlayback. 
			iNextHeaderCapture:           u32,
			// [0,periods). Used as an index into pWAVEHDRCapture. 
			headerFramesConsumedPlayback: u32,
			// The number of PCM frames consumed in the buffer in pWAVEHEADER[iNextHeader]. 
			headerFramesConsumedCapture:  u32,
			pWAVEHDRPlayback:             [^]u8,
			pWAVEHDRCapture:              [^]u8,
			// One instantiation for each period. 
			pIntermediaryBufferPlayback:  [^]u8,
			pIntermediaryBufferCapture:   [^]u8,
			_pHeapData:                   [^]u8,
		},
		alsa:        struct {},
		pulse:       struct {},
		jack:        struct {
			pClient:                     rawptr,
			pPortsPlayback:              [^]rawptr,
			pPortsCapture:               [^]rawptr,
			pIntermediaryBufferPlayback: [^]f32,
			// Typed as a float because JACK is always floating point. 
			pIntermediaryBufferCapture:  [^]f32,
		},
		coreaudio:   struct {},
		sndio:       struct {},
		audio4:      struct {},
		oss:         struct {},
		aaudio:      struct {},
		opensl:      struct {},
		webaudio:    struct {},
		null_device: struct {
			deviceThread:                         thread,
			operationEvent:                       event,
			operationCompletionEvent:             event,
			operationSemaphore:                   semaphore,
			operation:                            u32,
			operationResult:                      result,
			timer:                                timer,
			priorRunTime:                         f64,
			currentPeriodFramesRemainingPlayback: u32,
			currentPeriodFramesRemainingCapture:  u32,
			lastProcessedFramePlayback:           u64,
			lastProcessedFrameCapture:            u64,
			sStarted:                             b32,
		},
	},
}

device_config :: struct {
	deviceType:                device_type,
	sampleRate:                u32,
	periodSizeInFrames:        u32,
	periodSizeInMilliseconds:  u32,
	periods:                   u32,
	performanceProfile:        performance_profile,
	noPreSilencedOutputBuffer: b8,
	// When set to true, the contents of the output buffer passed into the data callback will be left undefined rather than initialized to zero. 
	noClip:                    b8,
	// When set to true, the contents of the output buffer passed into the data callback will not be clipped after returning. Only applies when the playback sample format is f32. 
	noDisableDenormals:        b8,
	// Do not disable denormals when firing the data callback. 
	noFixedSizedCallback:      b8,
	// Disables strict fixed-sized data callbacks. Setting this to true will result in the period size being treated only as a hint to the backend. This is an optimization for those who don't need fixed sized callbacks. 
	dataCallback:              device_data_proc,
	notificationCallback:      device_notification_proc,
	stopCallback:              stop_proc,
	pUserData:                 rawptr,
	resampling:                resampler_config,
	playback:                  struct {
		pDeviceID:                       ^device_id,
		format:                          format,
		channels:                        u32,
		channelMap:                      [^]channel,
		channelMixMode:                  channel_mix_mode,
		calculateLFEFromSpatialChannels: b32,
		// When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. 
		shareMode:                       share_mode,
	},
	capture:                   struct {
		pDeviceID:                       ^device_id,
		format:                          format,
		channels:                        u32,
		channelMap:                      [^]channel,
		channelMixMode:                  channel_mix_mode,
		calculateLFEFromSpatialChannels: b32,
		// When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. 
		shareMode:                       share_mode,
	},
	wasapi:                    struct {
		usage:                  wasapi_usage,
		// When configured, uses Avrt APIs to set the thread characteristics. 
		noAutoConvertSRC:       b8,
		// When set to true, disables the use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM. 
		noDefaultQualitySRC:    b8,
		// When set to true, disables the use of AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY. 
		noAutoStreamRouting:    b8,
		// Disables automatic stream routing. 
		noHardwareOffloading:   b8,
		// Disables WASAPI's hardware offloading feature. 
		loopbackProcessID:      u32,
		// The process ID to include or exclude for loopback mode. Set to 0 to capture audio from all processes. Ignored when an explicit device ID is specified. 
		loopbackProcessExclude: b8,
	},
	alsa:                      struct {
		noMMap:         b32,
		// Disables MMap mode. 
		noAutoFormat:   b32,
		// Opens the ALSA device with SND_PCM_NO_AUTO_FORMAT. 
		noAutoChannels: b32,
		// Opens the ALSA device with SND_PCM_NO_AUTO_CHANNELS. 
		noAutoResample: b32,
	},
	pulse:                     struct {
		pStreamNamePlayback: cstring,
		pStreamNameCapture:  cstring,
	},
	coreaudio:                 struct {
		allowNominalSampleRateChange: b32,
	},
	opensl:                    struct {
		streamType:                     opensl_stream_type,
		recordingPreset:                opensl_recording_preset,
		enableCompatibilityWorkarounds: b32,
	},
	aaudio:                    struct {
		usage:                          aaudio_usage,
		contentType:                    aaudio_content_type,
		inputPreset:                    aaudio_input_preset,
		allowedCapturePolicy:           aaudio_allowed_capture_policy,
		noAutoStartAfterReroute:        b32,
		enableCompatibilityWorkarounds: b32,
	},
}

device_data_proc :: proc "c" (pDevice: ^device, pOutput, pInput: rawptr, frameCount: u32)

device_descriptor :: struct {
	pDeviceID:                ^device_id,
	shareMode:                share_mode,
	format:                   format,
	channels:                 u32,
	sampleRate:               u32,
	channelMap:               [254]channel,
	periodSizeInFrames:       u32,
	periodSizeInMilliseconds: u32,
	periodCount:              u32,
}

device_id :: struct #raw_union {
	wasapi:      [64]u16,
	// WASAPI uses a wchar_t string for identification. 
	dsound:      [16]u8,
	winmm:       u32,
	// When creating a device, WinMM expects a Win32 UINT_PTR for device identification. In practice it's actually just a UINT. 
	alsa:        [256]u8,
	// ALSA uses a name string for identification. 
	pulse:       [256]u8,
	// PulseAudio uses a name string for identification. 
	jack:        i32,
	// JACK always uses default devices. 
	coreaudio:   [256]u8,
	// Core Audio uses a string for identification. 
	sndio:       [256]u8,
	// "snd/0", etc. 
	audio4:      [256]u8,
	// "/dev/audio", etc. 
	oss:         [64]u8,
	// "dev/dsp0", etc. "dev/dsp" for the default device. 
	aaudio:      i32,
	// AAudio uses a 32-bit integer for identification. 
	opensl:      u32,
	// OpenSL|ES uses a 32-bit unsigned integer for identification. 
	webaudio:    [32]u8,
	// Web Audio always uses default devices for now, but if this changes it'll be a GUID. 
	custom:      struct #raw_union {
		i: i32,
		s: [256]u8,
		p: rawptr,
	},
	// The custom backend could be anything. Give them a few options. 
	nullbackend: i32,
}

device_info :: struct {
	// Basic info. This is the only information guaranteed to be filled in during device enumeration. 
	id:                    device_id,
	name:                  [256]u8,
	// +1 for null terminator. 
	isDefault:             b32,
	nativeDataFormatCount: u32,
	nativeDataFormats:     [64]struct {
		// Not sure how big to make this. There can be *many* permutations for virtual devices which can support anything. 
		format:     format,
		// Sample format. If set to ma_format_unknown, all sample formats are supported. 
		channels:   u32,
		// If set to 0, all channels are supported. 
		sampleRate: u32,
		// If set to 0, all sample rates are supported. 
		flags:      u32,
	},
}

device_job_thread :: struct {
	thread:     thread,
	jobQueue:   job_queue,
	_hasThread: b32,
}

device_job_thread_config :: struct {
	noThread:         b32,
	// Set this to true if you want to process jobs yourself. 
	jobQueueCapacity: u32,
	jobQueueFlags:    u32,
}

device_notification :: struct {
	pDevice: ^device,
	type:    device_notification_type,
	data:    struct #raw_union {
		started:      struct {
			_unused: i32,
		},
		stopped:      struct {
			_unused: i32,
		},
		rerouted:     struct {
			_unused: i32,
		},
		interruption: struct {
			_unused: i32,
		},
	},
}

device_notification_proc :: proc "c" (pNotification: ^device_notification)

device_notification_type :: enum i32 {
	started, 
	stopped, 
	rerouted, 
	interruption_began, 
	interruption_ended, 
	unlocked, 
}

device_state :: enum i32 {
	uninitialized = 0, 
	stopped       = 1, // The device's default state after initialization.
	started       = 2, // The device is started and is requesting and/or delivering audio data.
	starting      = 3, // Transitioning from a stopped state to started.
	stopping      = 4, // Transitioning from a started state to stopped.
}

device_type :: enum i32 {
	playback = 1, 
	capture  = 2, 
	duplex   = 3, // playback | capture
	loopback = 4, 
}

dither_mode :: enum i32 {
	none      = 0, 
	rectangle, 
	triangle, 
}

duplex_rb :: struct {
	rb: pcm_rb,
}

encoder :: struct {
	config:           encoder_config,
	onWrite:          encoder_write_proc,
	onSeek:           encoder_seek_proc,
	onInit:           encoder_init_proc,
	onUninit:         encoder_uninit_proc,
	onWritePCMFrames: encoder_write_pcm_frames_proc,
	pUserData:        rawptr,
	pInternalEncoder: rawptr,
	data:             struct {
		vfs: struct {
			pVFS: ^vfs,
			file: vfs_file,
		},
	},
}

encoder_config :: struct {
	encodingFormat:      encoding_format,
	format:              format,
	channels:            u32,
	sampleRate:          u32,
	allocationCallbacks: allocation_callbacks,
}

encoder_init_proc :: proc "c" (pEncoder: ^encoder) -> result

encoder_seek_proc :: proc "c" (pEncoder: ^encoder, offset: i64, origin: seek_origin) -> result

encoder_uninit_proc :: proc "c" (pEncoder: ^encoder)

encoder_write_pcm_frames_proc :: proc "c" (pEncoder: ^encoder, pFramesIn: rawptr, frameCount: u64, pFramesWritten: ^u64) -> result

encoder_write_proc :: proc "c" (pEncoder: ^encoder, pBufferIn: rawptr, bytesToWrite: uint, pBytesWritten: ^uint) -> result

encoding_format :: enum i32 {
	unknown = 0, 
	wav, 
	flac, 
	mp3, 
	vorbis, 
}

engine :: struct {
	nodeGraph:                          node_graph,
	// An engine is a node graph. It should be able to be plugged into any ma_node_graph API (with a cast) which means this must be the first member of this struct. 
	pResourceManager:                   ^resource_manager,
	pDevice:                            ^device,
	// Optionally set via the config, otherwise allocated by the engine in ma_engine_init(). 
	pLog:                               ^log,
	sampleRate:                         u32,
	listenerCount:                      u32,
	listeners:                          [4]spatializer_listener,
	allocationCallbacks:                allocation_callbacks,
	ownsResourceManager:                b8,
	ownsDevice:                         b8,
	inlinedSoundLock:                   spinlock,
	// For synchronizing access so the inlined sound list. 
	pInlinedSoundHead:                  ^sound_inlined,
	// The first inlined sound. Inlined sounds are tracked in a linked list. 
	inlinedSoundCount:                  u32,
	// atomic
	// The total number of allocated inlined sound objects. Used for debugging. 
	gainSmoothTimeInFrames:             u32,
	// The number of frames to interpolate the gain of spatialized sounds across. 
	defaultVolumeSmoothTimeInPCMFrames: u32,
	monoExpansionMode:                  mono_expansion_mode,
	onProcess:                          engine_process_proc,
	pProcessUserData:                   rawptr,
}

engine_config :: struct {
	pResourceManager:                   ^resource_manager,
	// Can be null in which case a resource manager will be created for you. 
	pContext:                           ^context_type,
	pDevice:                            ^device,
	// If set, the caller is responsible for calling ma_engine_data_callback() in the device's data callback. 
	pPlaybackDeviceID:                  ^device_id,
	// The ID of the playback device to use with the default listener. 
	dataCallback:                       device_data_proc,
	// Can be null. Can be used to provide a custom device data callback. 
	notificationCallback:               device_notification_proc,
	pLog:                               ^log,
	// When set to NULL, will use the context's log. 
	listenerCount:                      u32,
	// Must be between 1 and MA_ENGINE_MAX_LISTENERS. 
	channels:                           u32,
	// The number of channels to use when mixing and spatializing. When set to 0, will use the native channel count of the device. 
	sampleRate:                         u32,
	// The sample rate. When set to 0 will use the native channel count of the device. 
	periodSizeInFrames:                 u32,
	// If set to something other than 0, updates will always be exactly this size. The underlying device may be a different size, but from the perspective of the mixer that won't matter.
	periodSizeInMilliseconds:           u32,
	// Used if periodSizeInFrames is unset. 
	gainSmoothTimeInFrames:             u32,
	// The number of frames to interpolate the gain of spatialized sounds across. If set to 0, will use gainSmoothTimeInMilliseconds. 
	gainSmoothTimeInMilliseconds:       u32,
	// When set to 0, gainSmoothTimeInFrames will be used. If both are set to 0, a default value will be used. 
	defaultVolumeSmoothTimeInPCMFrames: u32,
	// Defaults to 0. Controls the default amount of smoothing to apply to volume changes to sounds. High values means more smoothing at the expense of high latency (will take longer to reach the new volume). 
	allocationCallbacks:                allocation_callbacks,
	noAutoStart:                        b32,
	// When set to true, requires an explicit call to ma_engine_start(). This is false by default, meaning the engine will be started automatically in ma_engine_init(). 
	noDevice:                           b32,
	// When set to true, don't create a default device. ma_engine_read_pcm_frames() can be called manually to read data. 
	monoExpansionMode:                  mono_expansion_mode,
	// Controls how the mono channel should be expanded to other channels when spatialization is disabled on a sound. 
	pResourceManagerVFS:                ^vfs,
	// A pointer to a pre-allocated VFS object to use with the resource manager. This is ignored if pResourceManager is not NULL. 
	onProcess:                          engine_process_proc,
	// Fired at the end of each call to ma_engine_read_pcm_frames(). For engine's that manage their own internal device (the default configuration), this will be fired from the audio thread, and you do not need to call ma_engine_read_pcm_frames() manually in order to trigger this. 
	pProcessUserData:                   rawptr,
}

engine_node :: struct {
	baseNode:                    node_base,
	// Must be the first member for compatiblity with the ma_node API. 
	pEngine:                     ^engine,
	// A pointer to the engine. Set based on the value from the config. 
	sampleRate:                  u32,
	// The sample rate of the input data. For sounds backed by a data source, this will be the data source's sample rate. Otherwise it'll be the engine's sample rate. 
	volumeSmoothTimeInPCMFrames: u32,
	monoExpansionMode:           mono_expansion_mode,
	fader:                       fader,
	resampler:                   linear_resampler,
	// For pitch shift. 
	spatializer:                 spatializer,
	panner:                      panner,
	volumeGainer:                gainer,
	// This will only be used if volumeSmoothTimeInPCMFrames is > 0. 
	volume:                      f32,
	// atomic
	// Defaults to 1. 
	pitch:                       f32,
	// atomic
	oldPitch:                    f32,
	// For determining whether or not the resampler needs to be updated to reflect the new pitch. The resampler will be updated on the mixing thread. 
	oldDopplerPitch:             f32,
	// For determining whether or not the resampler needs to be updated to take a new doppler pitch into account. 
	isPitchDisabled:             b32,
	// atomic
	// When set to true, pitching will be disabled which will allow the resampler to be bypassed to save some computation. 
	isSpatializationDisabled:    b32,
	// atomic
	// Set to false by default. When set to false, will not have spatialisation applied. 
	pinnedListenerIndex:         u32,
	// atomic
	// The index of the listener this node should always use for spatialization. If set to MA_LISTENER_INDEX_CLOSEST the engine will use the closest listener. 
	fadeSettings:                struct {
		volumeBeg:                  f32,
		// atomic
		volumeEnd:                  f32,
		// atomic
		fadeLengthInFrames:         u64,
		// atomic
		// <-- Defaults to (~(ma_uint64)0) which is used to indicate that no fade should be applied. 
		absoluteGlobalTimeInFrames: u64,
	},
	// Memory management. 
	_ownsHeap:                   b8,
	_pHeap:                      rawptr,
}

engine_node_config :: struct {
	pEngine:                     ^engine,
	type:                        engine_node_type,
	channelsIn:                  u32,
	channelsOut:                 u32,
	sampleRate:                  u32,
	// Only used when the type is set to ma_engine_node_type_sound. 
	volumeSmoothTimeInPCMFrames: u32,
	monoExpansionMode:           mono_expansion_mode,
	isPitchDisabled:             b8,
	// Pitching can be explicitly disable with MA_SOUND_FLAG_NO_PITCH to optimize processing. 
	isSpatializationDisabled:    b8,
	// Spatialization can be explicitly disabled with MA_SOUND_FLAG_NO_SPATIALIZATION. 
	pinnedListenerIndex:         u8,
}

engine_node_type :: enum i32 {
	sound, 
	group, 
}

engine_process_proc :: proc "c" (pUserData: rawptr, pFramesOut: [^]f32, frameCount: u64)

enum_devices_callback_proc :: proc "c" (pContext: ^context_type, deviceType: device_type, pInfo: ^device_info, pUserData: rawptr) -> b32

event :: distinct rawptr

fader :: struct {
	config:         fader_config,
	volumeBeg:      f32,
	// If volumeBeg and volumeEnd is equal to 1, no fading happens (ma_fader_process_pcm_frames() will run as a passthrough). 
	volumeEnd:      f32,
	lengthInFrames: u64,
	// The total length of the fade. 
	cursorInFrames: i64,
}

fader_config :: struct {
	format:     format,
	channels:   u32,
	sampleRate: u32,
}

fence :: struct {
	e:       event,
	counter: struct {},
}

file_info :: struct {
	sizeInBytes: u64,
}

format :: enum i32 {
	// 	I like to keep these explicitly defined because they're used as a key into a lookup table. When items are
	// 	added to this, make sure there are no gaps and that they're added to the lookup table in ma_get_bytes_per_sample().
	unknown = 0, // Mainly used for indicating an error, but also used as the default for the output format for decoders.
	u8      = 1, 
	s16     = 2, // Seems to be the most widely supported format.
	s24     = 3, // Tightly packed. 3 bytes per sample.
	s32     = 4, 
	f32     = 5, 
}

gainer :: struct {
	config:       gainer_config,
	t:            u32,
	masterVolume: f32,
	pOldGains:    [^]f32,
	pNewGains:    [^]f32,
	// Memory management. 
	_pHeap:       rawptr,
	_ownsHeap:    b32,
}

gainer_config :: struct {
	channels:           u32,
	smoothTimeInFrames: u32,
}

handedness :: enum i32 {
	right, 
	left, 
}

handle :: distinct rawptr

hishelf2 :: struct {
	bq: biquad,
}

hishelf2_config :: hishelf_config

hishelf_config :: struct {
	format:     format,
	channels:   u32,
	sampleRate: u32,
	gainDB:     f64,
	shelfSlope: f64,
	frequency:  f64,
}

hishelf_node :: struct {
	baseNode: node_base,
	hishelf:  hishelf2,
}

hishelf_node_config :: struct {
	nodeConfig: node_config,
	hishelf:    hishelf_config,
}

hpf :: struct {
	format:     format,
	channels:   u32,
	sampleRate: u32,
	hpf1Count:  u32,
	hpf2Count:  u32,
	pHPF1:      ^hpf1,
	pHPF2:      ^hpf2,
	// Memory management. 
	_pHeap:     rawptr,
	_ownsHeap:  b32,
}

hpf1 :: struct {
	format:    format,
	channels:  u32,
	a:         biquad_coefficient,
	pR1:       ^biquad_coefficient,
	// Memory management. 
	_pHeap:    rawptr,
	_ownsHeap: b32,
}

hpf1_config :: struct {
	format:          format,
	channels:        u32,
	sampleRate:      u32,
	cutoffFrequency: f64,
	q:               f64,
}

hpf2 :: struct {
	bq: biquad,
}

hpf2_config :: hpf1_config

hpf_config :: struct {
	format:          format,
	channels:        u32,
	sampleRate:      u32,
	cutoffFrequency: f64,
	order:           u32,
}

hpf_node :: struct {
	baseNode: node_base,
	hpf:      hpf,
}

hpf_node_config :: struct {
	nodeConfig: node_config,
	hpf:        hpf_config,
}

ios_session_category :: enum i32 {
	default         = 0, // AVAudioSessionCategoryPlayAndRecord.
	none,                // Leave the session category unchanged.
	ambient,             // AVAudioSessionCategoryAmbient
	solo_ambient,        // AVAudioSessionCategorySoloAmbient
	playback,            // AVAudioSessionCategoryPlayback
	record,              // AVAudioSessionCategoryRecord
	play_and_record,     // AVAudioSessionCategoryPlayAndRecord
	multi_route,         // AVAudioSessionCategoryMultiRoute
}

ios_session_category_option :: enum i32 {
	mix_with_others                            = 1,  // AVAudioSessionCategoryOptionMixWithOthers
	duck_others                                = 2,  // AVAudioSessionCategoryOptionDuckOthers
	allow_bluetooth                            = 4,  // AVAudioSessionCategoryOptionAllowBluetooth
	default_to_speaker                         = 8,  // AVAudioSessionCategoryOptionDefaultToSpeaker
	interrupt_spoken_audio_and_mix_with_others = 17, // AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers
	allow_bluetooth_a2dp                       = 32, // AVAudioSessionCategoryOptionAllowBluetoothA2DP
	allow_air_play                             = 64, // AVAudioSessionCategoryOptionAllowAirPlay
}

job :: struct {
	toc:   struct #raw_union {
		// 8 bytes. We encode the job code into the slot allocation data to save space. 
		breakup:    struct {
			code:     u16,
			// Job type. 
			slot:     u16,
			// Index into a ma_slot_allocator. 
			refcount: u32,
		},
		allocation: u64,
	},
	next:  u64,
	// atomic
	// refcount + slot for the next item. Does not include the job code. 
	order: u32,
	// Execution order. Used to create a data dependency and ensure a job is executed in order. Usage is contextual depending on the job type. 
	data:  struct #raw_union {
		// Miscellaneous. 
		custom:          struct {
			proc_: job_proc,
			data0: uintptr,
			data1: uintptr,
		},
		// Resource Manager 
		resourceManager: struct #raw_union {
			loadDataBufferNode: struct {
				pResourceManager:  rawptr,
				pDataBufferNode:   rawptr,
				pFilePath:         cstring,
				pFilePathW:        [^]u16,
				flags:             u32,
				// Resource manager data source flags that were used when initializing the data buffer. 
				pInitNotification: ^async_notification,
				// Signalled when the data buffer has been initialized and the format/channels/rate can be retrieved. 
				pDoneNotification: ^async_notification,
				// Signalled when the data buffer has been fully decoded. Will be passed through to MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE when decoding. 
				pInitFence:        ^fence,
				// Released when initialization of the decoder is complete. 
				pDoneFence:        ^fence,
			},
			freeDataBufferNode: struct {
				pResourceManager:  rawptr,
				pDataBufferNode:   rawptr,
				pDoneNotification: ^async_notification,
				pDoneFence:        ^fence,
			},
			pageDataBufferNode: struct {
				pResourceManager:  rawptr,
				pDataBufferNode:   rawptr,
				pDecoder:          rawptr,
				pDoneNotification: ^async_notification,
				// Signalled when the data buffer has been fully decoded. 
				pDoneFence:        ^fence,
			},
			loadDataBuffer:     struct {
				pDataBuffer:             rawptr,
				pInitNotification:       ^async_notification,
				// Signalled when the data buffer has been initialized and the format/channels/rate can be retrieved. 
				pDoneNotification:       ^async_notification,
				// Signalled when the data buffer has been fully decoded. 
				pInitFence:              ^fence,
				// Released when the data buffer has been initialized and the format/channels/rate can be retrieved. 
				pDoneFence:              ^fence,
				// Released when the data buffer has been fully decoded. 
				rangeBegInPCMFrames:     u64,
				rangeEndInPCMFrames:     u64,
				loopPointBegInPCMFrames: u64,
				loopPointEndInPCMFrames: u64,
				isLooping:               u32,
			},
			freeDataBuffer:     struct {
				pDataBuffer:       rawptr,
				pDoneNotification: ^async_notification,
				pDoneFence:        ^fence,
			},
			loadDataStream:     struct {
				pDataStream:       rawptr,
				pFilePath:         cstring,
				// Allocated when the job is posted, freed by the job thread after loading. 
				pFilePathW:        [^]u16,
				// ^ As above ^. Only used if pFilePath is NULL. 
				initialSeekPoint:  u64,
				pInitNotification: ^async_notification,
				// Signalled after the first two pages have been decoded and frames can be read from the stream. 
				pInitFence:        ^fence,
			},
			freeDataStream:     struct {
				pDataStream:       rawptr,
				pDoneNotification: ^async_notification,
				pDoneFence:        ^fence,
			},
			pageDataStream:     struct {
				pDataStream: rawptr,
				pageIndex:   u32,
			},
			seekDataStream:     struct {
				pDataStream: rawptr,
				frameIndex:  u64,
			},
		},
		// Device. 
		device:          struct {
			aaudio: struct {
				reroute: struct {
					pDevice:    rawptr,
					deviceType: u32,
				},
			},
		},
	},
}

job_proc :: proc "c" (pJob: ^job)

job_queue :: struct {
	flags:     u32,
	// Flags passed in at initialization time. 
	capacity:  u32,
	// The maximum number of jobs that can fit in the queue at a time. Set by the config. 
	head:      u64,
	// atomic
	// The first item in the list. Required for removing from the top of the list. 
	tail:      u64,
	// atomic
	// The last item in the list. Required for appending to the end of the list. 
	sem:       semaphore,
	// Only used when MA_JOB_QUEUE_FLAG_NON_BLOCKING is unset. 
	allocator: slot_allocator,
	pJobs:     [^]job,
	lock:      spinlock,
	// Memory management. 
	_pHeap:    rawptr,
	_ownsHeap: b32,
}

job_queue_config :: struct {
	flags:    u32,
	capacity: u32,
}

job_queue_flags :: enum i32 {
	NON_BLOCKING = 1, 
}

job_type :: enum i32 {
	// Miscellaneous. 
	QUIT                                   = 0, 
	CUSTOM, 
	// Resource Manager. 
	RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE, 
	RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE, 
	RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE, 
	RESOURCE_MANAGER_LOAD_DATA_BUFFER, 
	RESOURCE_MANAGER_FREE_DATA_BUFFER, 
	RESOURCE_MANAGER_LOAD_DATA_STREAM, 
	RESOURCE_MANAGER_FREE_DATA_STREAM, 
	RESOURCE_MANAGER_PAGE_DATA_STREAM, 
	RESOURCE_MANAGER_SEEK_DATA_STREAM, 
	// Device. 
	DEVICE_AAUDIO_REROUTE, 
	// Count. Must always be last. 
	COUNT, 
}

lcg :: struct {
	state: i32,
}

linear_resampler :: struct {
	config:        linear_resampler_config,
	inAdvanceInt:  u32,
	inAdvanceFrac: u32,
	inTimeInt:     u32,
	inTimeFrac:    u32,
	x0:            struct #raw_union {
		f32: [^]f32,
		s16: [^]i16,
	},
	// The previous input frame. 
	x1:            struct #raw_union {
		f32: [^]f32,
		s16: [^]i16,
	},
	// The next input frame. 
	lpf:           lpf,
	// Memory management. 
	_pHeap:        rawptr,
	_ownsHeap:     b32,
}

linear_resampler_config :: struct {
	format:           format,
	channels:         u32,
	sampleRateIn:     u32,
	sampleRateOut:    u32,
	lpfOrder:         u32,
	// The low-pass filter order. Setting this to 0 will disable low-pass filtering. 
	lpfNyquistFactor: f64,
}

log :: struct {
	callbacks:           [4]log_callback,
	callbackCount:       u32,
	allocationCallbacks: allocation_callbacks,
	// Need to store these persistently because log_postv() might need to allocate a buffer on the heap. 
	lock:                mutex,
}

log_callback :: struct {
	onLog:     log_callback_proc,
	pUserData: rawptr,
}