package vendor:android/opensles

Source

SL3DCommitItf :: ^struct {
	using itf: ^SL3DCommitItf_,
}

SL3DCommitItf_ :: struct {
	Commit:      proc "c" (self: ^struct {
		using itf: ^SL3DCommitItf_,
	}) -> u32,
	SetDeferred: proc "c" (self: ^struct {
		using itf: ^SL3DCommitItf_,
	}, deferred: u32) -> u32,
}

SL3DDopplerItf :: ^struct {
	using itf: ^SL3DDopplerItf_,
}

SL3DDopplerItf_ :: struct {
	SetVelocityCartesian: proc "c" (self: ^struct {
		using itf: ^SL3DDopplerItf_,
	}, pVelocity: ^SLVec3D) -> u32,
	SetVelocitySpherical: proc "c" (self: ^struct {
		using itf: ^SL3DDopplerItf_,
	}, azimuth: i32, elevation: i32, speed: i32) -> u32,
	GetVelocityCartesian: proc "c" (self: ^struct {
		using itf: ^SL3DDopplerItf_,
	}, pVelocity: ^SLVec3D) -> u32,
	SetDopplerFactor:     proc "c" (self: ^struct {
		using itf: ^SL3DDopplerItf_,
	}, dopplerFactor: i16) -> u32,
	GetDopplerFactor:     proc "c" (self: ^struct {
		using itf: ^SL3DDopplerItf_,
	}, pDopplerFactor: ^i16) -> u32,
}

SL3DGroupingItf :: ^struct {
	using itf: ^SL3DGroupingItf_,
}

SL3DGroupingItf_ :: struct {
	Set3DGroup: proc "c" (self: ^struct {
		using itf: ^SL3DGroupingItf_,
	}, group: ^struct {
		using itf: ^SLObjectItf_,
	}) -> u32,
	Get3DGroup: proc "c" (self: ^struct {
		using itf: ^SL3DGroupingItf_,
	}, pGroup: ^^struct {
		using itf: ^SLObjectItf_,
	}) -> u32,
}

SL3DLocationItf :: ^struct {
	using itf: ^SL3DLocationItf_,
}

SL3DLocationItf_ :: struct {
	SetLocationCartesian:  proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, pLocation: ^SLVec3D) -> u32,
	SetLocationSpherical:  proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, azimuth: i32, elevation: i32, distance: i32) -> u32,
	Move:                  proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, pMovement: ^SLVec3D) -> u32,
	GetLocationCartesian:  proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, pLocation: ^SLVec3D) -> u32,
	SetOrientationVectors: proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, pFront: ^SLVec3D, pAbove: ^SLVec3D) -> u32,
	SetOrientationAngles:  proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, heading: i32, pitch: i32, roll: i32) -> u32,
	Rotate:                proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, theta: i32, pAxis: ^SLVec3D) -> u32,
	GetOrientationVectors: proc "c" (self: ^struct {
		using itf: ^SL3DLocationItf_,
	}, pFront: ^SLVec3D, pUp: ^SLVec3D) -> u32,
}

SL3DMacroscopicItf :: ^struct {
	using itf: ^SL3DMacroscopicItf_,
}

SL3DMacroscopicItf_ :: struct {
	SetSize:               proc "c" (self: ^struct {
		using itf: ^SL3DMacroscopicItf_,
	}, width: i32, height: i32, depth: i32) -> u32,
	GetSize:               proc "c" (self: ^struct {
		using itf: ^SL3DMacroscopicItf_,
	}, pWidth: ^i32, pHeight: ^i32, pDepth: ^i32) -> u32,
	SetOrientationAngles:  proc "c" (self: ^struct {
		using itf: ^SL3DMacroscopicItf_,
	}, heading: i32, pitch: i32, roll: i32) -> u32,
	SetOrientationVectors: proc "c" (self: ^struct {
		using itf: ^SL3DMacroscopicItf_,
	}, pFront: ^SLVec3D, pAbove: ^SLVec3D) -> u32,
	Rotate:                proc "c" (self: ^struct {
		using itf: ^SL3DMacroscopicItf_,
	}, theta: i32, pAxis: ^SLVec3D) -> u32,
	GetOrientationVectors: proc "c" (self: ^struct {
		using itf: ^SL3DMacroscopicItf_,
	}, pFront: ^SLVec3D, pUp: ^SLVec3D) -> u32,
}

SL3DSourceItf :: ^struct {
	using itf: ^SL3DSourceItf_,
}

SL3DSourceItf_ :: struct {
	SetHeadRelative:           proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, headRelative: u32) -> u32,
	GetHeadRelative:           proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, pHeadRelative: ^u32) -> u32,
	SetRolloffDistances:       proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, minDistance: i32, maxDistance: i32) -> u32,
	GetRolloffDistances:       proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, pMinDistance: ^i32, pMaxDistance: ^i32) -> u32,
	SetRolloffMaxDistanceMute: proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, mute: u32) -> u32,
	GetRolloffMaxDistanceMute: proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, pMute: ^u32) -> u32,
	SetRolloffFactor:          proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, rolloffFactor: i16) -> u32,
	GetRolloffFactor:          proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, pRolloffFactor: ^i16) -> u32,
	SetRoomRolloffFactor:      proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, roomRolloffFactor: i16) -> u32,
	GetRoomRolloffFactor:      proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, pRoomRolloffFactor: ^i16) -> u32,
	SetRolloffModel:           proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, model: u8) -> u32,
	GetRolloffModel:           proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, pModel: ^u8) -> u32,
	SetCone:                   proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, innerAngle: i32, outerAngle: i32, outerLevel: i16) -> u32,
	GetCone:                   proc "c" (self: ^struct {
		using itf: ^SL3DSourceItf_,
	}, pInnerAngle: ^i32, pOuterAngle: ^i32, pOuterLevel: ^i16) -> u32,
}

SLAint64 :: i64

SLAndroidAcousticEchoCancellationItf :: ^struct {
	using itf: ^SLAndroidAcousticEchoCancellationItf_,
}

SLAndroidAcousticEchoCancellationItf_ :: struct {
	SetEnabled: proc "c" (self: ^struct {
		using itf: ^SLAndroidAcousticEchoCancellationItf_,
	}, enabled: u32) -> u32,
	IsEnabled:  proc "c" (self: ^struct {
		using itf: ^SLAndroidAcousticEchoCancellationItf_,
	}, pEnabled: ^u32) -> u32,
}

SLAndroidAutomaticGainControlItf :: ^struct {
	using itf: ^SLAndroidAutomaticGainControlItf_,
}

SLAndroidAutomaticGainControlItf_ :: struct {
	SetEnabled: proc "c" (self: ^struct {
		using itf: ^SLAndroidAutomaticGainControlItf_,
	}, enabled: u32) -> u32,
	IsEnabled:  proc "c" (self: ^struct {
		using itf: ^SLAndroidAutomaticGainControlItf_,
	}, pEnabled: ^u32) -> u32,
}

SLAndroidBufferItem :: struct {
	itemKey:  u32,
	itemSize: u32,
	itemData: [0]u8,
}

SLAndroidBufferQueueItf :: ^struct {
	using itf: ^SLAndroidBufferQueueItf_,
}

SLAndroidBufferQueueItf_ :: struct {
	RegisterCallback:      proc "c" (self: ^struct {
		using itf: ^SLAndroidBufferQueueItf_,
	}, callback: slAndroidBufferQueueCallback, pCallbackContext: rawptr) -> u32,
	Clear:                 proc "c" (self: ^struct {
		using itf: ^SLAndroidBufferQueueItf_,
	}) -> u32,
	Enqueue:               proc "c" (self: ^struct {
		using itf: ^SLAndroidBufferQueueItf_,
	}, pBufferContext: rawptr, pData: rawptr, dataLength: u32, pItems: ^SLAndroidBufferItem, itemsLength: u32) -> u32,
	GetState:              proc "c" (self: ^struct {
		using itf: ^SLAndroidBufferQueueItf_,
	}, pState: ^SLAndroidBufferQueueState) -> u32,
	SetCallbackEventsMask: proc "c" (self: ^struct {
		using itf: ^SLAndroidBufferQueueItf_,
	}, eventFlags: u32) -> u32,
	GetCallbackEventsMask: proc "c" (self: ^struct {
		using itf: ^SLAndroidBufferQueueItf_,
	}, pEventFlags: ^u32) -> u32,
}

SLAndroidBufferQueueState :: struct {
	count: u32,
	index: u32,
}

SLAndroidConfigurationItf :: ^struct {
	using itf: ^SLAndroidConfigurationItf_,
}

SLAndroidConfigurationItf_ :: struct {
	SetConfiguration: proc "c" (self: ^struct {
		using itf: ^SLAndroidConfigurationItf_,
	}, configKey: ^u8, pConfigValue: rawptr, valueSize: u32) -> u32,
	GetConfiguration: proc "c" (self: ^struct {
		using itf: ^SLAndroidConfigurationItf_,
	}, configKey: ^u8, pValueSize: ^u32, pConfigValue: rawptr) -> u32,
	AcquireJavaProxy: proc "c" (self: ^struct {
		using itf: ^SLAndroidConfigurationItf_,
	}, proxyType: u32, pProxyObj: ^rawptr) -> u32,
	ReleaseJavaProxy: proc "c" (self: ^struct {
		using itf: ^SLAndroidConfigurationItf_,
	}, proxyType: u32) -> u32,
}

SLAndroidDataFormat_PCM_EX :: struct {
	formatType:     u32,
	numChannels:    u32,
	sampleRate:     u32,
	bitsPerSample:  u32,
	containerSize:  u32,
	channelMask:    u32,
	endianness:     u32,
	representation: u32,
}

SLAndroidEffectCapabilitiesItf :: ^struct {
	using itf: ^SLAndroidEffectCapabilitiesItf_,
}

SLAndroidEffectCapabilitiesItf_ :: struct {
	QueryNumEffects: proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectCapabilitiesItf_,
	}, pNumSupportedEffects: ^u32) -> u32,
	QueryEffect:     proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectCapabilitiesItf_,
	}, index: u32, pEffectType: ^^SLInterfaceID_, pEffectImplementation: ^^SLInterfaceID_, pName: ^u8, pNameSize: ^u16) -> u32,
}

SLAndroidEffectItf :: ^struct {
	using itf: ^SLAndroidEffectItf_,
}

SLAndroidEffectItf_ :: struct {
	CreateEffect:  proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectItf_,
	}, effectImplementationId: ^SLInterfaceID_) -> u32,
	ReleaseEffect: proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectItf_,
	}, effectImplementationId: ^SLInterfaceID_) -> u32,
	SetEnabled:    proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectItf_,
	}, effectImplementationId: ^SLInterfaceID_, enabled: u32) -> u32,
	IsEnabled:     proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectItf_,
	}, effectImplementationId: ^SLInterfaceID_, pEnabled: ^u32) -> u32,
	SendCommand:   proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectItf_,
	}, effectImplementationId: ^SLInterfaceID_, command: u32, commandSize: u32, pCommandData: rawptr, replySize: ^u32, pReplyData: rawptr) -> u32,
}

SLAndroidEffectSendItf :: ^struct {
	using itf: ^SLAndroidEffectSendItf_,
}

SLAndroidEffectSendItf_ :: struct {
	EnableEffectSend: proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectSendItf_,
	}, effectImplementationId: ^SLInterfaceID_, enable: u32, initialLevel: i16) -> u32,
	IsEnabled:        proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectSendItf_,
	}, effectImplementationId: ^SLInterfaceID_, pEnable: ^u32) -> u32,
	SetDirectLevel:   proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectSendItf_,
	}, directLevel: i16) -> u32,
	GetDirectLevel:   proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectSendItf_,
	}, pDirectLevel: ^i16) -> u32,
	SetSendLevel:     proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectSendItf_,
	}, effectImplementationId: ^SLInterfaceID_, sendLevel: i16) -> u32,
	GetSendLevel:     proc "c" (self: ^struct {
		using itf: ^SLAndroidEffectSendItf_,
	}, effectImplementationId: ^SLInterfaceID_, pSendLevel: ^i16) -> u32,
}

SLAndroidNoiseSuppressionItf :: ^struct {
	using itf: ^SLAndroidNoiseSuppressionItf_,
}

SLAndroidNoiseSuppressionItf_ :: struct {
	SetEnabled: proc "c" (self: ^struct {
		using itf: ^SLAndroidNoiseSuppressionItf_,
	}, enabled: u32) -> u32,
	IsEnabled:  proc "c" (self: ^struct {
		using itf: ^SLAndroidNoiseSuppressionItf_,
	}, pEnabled: ^u32) -> u32,
}

SLAndroidSimpleBufferQueueItf :: ^struct {
	using itf: ^SLAndroidSimpleBufferQueueItf_,
}

SLAndroidSimpleBufferQueueItf_ :: struct {
	Enqueue:          proc "c" (self: ^struct {
		using itf: ^SLAndroidSimpleBufferQueueItf_,
	}, pBuffer: rawptr, size: u32) -> u32,
	Clear:            proc "c" (self: ^struct {
		using itf: ^SLAndroidSimpleBufferQueueItf_,
	}) -> u32,
	GetState:         proc "c" (self: ^struct {
		using itf: ^SLAndroidSimpleBufferQueueItf_,
	}, pState: ^SLAndroidSimpleBufferQueueState) -> u32,
	RegisterCallback: proc "c" (self: ^struct {
		using itf: ^SLAndroidSimpleBufferQueueItf_,
	}, callback: slAndroidSimpleBufferQueueCallback, pContext: rawptr) -> u32,
}

SLAndroidSimpleBufferQueueState :: struct {
	count: u32,
	index: u32,
}

SLAudioCodecDescriptor :: struct {
	maxChannels:              u32,
	minBitsPerSample:         u32,
	maxBitsPerSample:         u32,
	minSampleRate:            u32,
	maxSampleRate:            u32,
	isFreqRangeContinuous:    u32,
	pSampleRatesSupported:    ^u32,
	numSampleRatesSupported:  u32,
	minBitRate:               u32,
	maxBitRate:               u32,
	isBitrateRangeContinuous: u32,
	pBitratesSupported:       ^u32,
	numBitratesSupported:     u32,
	profileSetting:           u32,
	modeSetting:              u32,
}

SLAudioCodecProfileMode :: struct {
	profileSetting: u32,
	modeSetting:    u32,
}

SLAudioDecoderCapabilitiesItf :: ^struct {
	using itf: ^SLAudioDecoderCapabilitiesItf_,
}

SLAudioDecoderCapabilitiesItf_ :: struct {
	GetAudioDecoders:            proc "c" (self: ^struct {
		using itf: ^SLAudioDecoderCapabilitiesItf_,
	}, pNumDecoders: ^u32, pDecoderIds: ^u32) -> u32,
	GetAudioDecoderCapabilities: proc "c" (self: ^struct {
		using itf: ^SLAudioDecoderCapabilitiesItf_,
	}, decoderId: u32, pIndex: ^u32, pDescriptor: ^SLAudioCodecDescriptor) -> u32,
}

SLAudioEncoderCapabilitiesItf :: ^struct {
	using itf: ^SLAudioEncoderCapabilitiesItf_,
}

SLAudioEncoderCapabilitiesItf_ :: struct {
	GetAudioEncoders:            proc "c" (self: ^struct {
		using itf: ^SLAudioEncoderCapabilitiesItf_,
	}, pNumEncoders: ^u32, pEncoderIds: ^u32) -> u32,
	GetAudioEncoderCapabilities: proc "c" (self: ^struct {
		using itf: ^SLAudioEncoderCapabilitiesItf_,
	}, encoderId: u32, pIndex: ^u32, pDescriptor: ^SLAudioCodecDescriptor) -> u32,
}

SLAudioEncoderItf :: ^struct {
	using itf: ^SLAudioEncoderItf_,
}

SLAudioEncoderItf_ :: struct {
	SetEncoderSettings: proc "c" (self: ^struct {
		using itf: ^SLAudioEncoderItf_,
	}, pSettings: ^SLAudioEncoderSettings) -> u32,
	GetEncoderSettings: proc "c" (self: ^struct {
		using itf: ^SLAudioEncoderItf_,
	}, pSettings: ^SLAudioEncoderSettings) -> u32,
}

SLAudioEncoderSettings :: struct {
	encoderId:      u32,
	channelsIn:     u32,
	channelsOut:    u32,
	sampleRate:     u32,
	bitRate:        u32,
	bitsPerSample:  u32,
	rateControl:    u32,
	profileSetting: u32,
	levelSetting:   u32,
	channelMode:    u32,
	streamFormat:   u32,
	encodeOptions:  u32,
	blockAlignment: u32,
}

SLAudioIODeviceCapabilitiesItf :: ^struct {
	using itf: ^SLAudioIODeviceCapabilitiesItf_,
}

SLAudioIODeviceCapabilitiesItf_ :: struct {
	GetAvailableAudioInputs:                      proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, pNumInputs: ^i32, pInputDeviceIDs: ^u32) -> u32,
	QueryAudioInputCapabilities:                  proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, deviceId: u32, pDescriptor: ^SLAudioInputDescriptor) -> u32,
	RegisterAvailableAudioInputsChangedCallback:  proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, callback: slAvailableAudioInputsChangedCallback, pContext: rawptr) -> u32,
	GetAvailableAudioOutputs:                     proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, pNumOutputs: ^i32, pOutputDeviceIDs: ^u32) -> u32,
	QueryAudioOutputCapabilities:                 proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, deviceId: u32, pDescriptor: ^SLAudioOutputDescriptor) -> u32,
	RegisterAvailableAudioOutputsChangedCallback: proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, callback: slAvailableAudioOutputsChangedCallback, pContext: rawptr) -> u32,
	RegisterDefaultDeviceIDMapChangedCallback:    proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, callback: slDefaultDeviceIDMapChangedCallback, pContext: rawptr) -> u32,
	GetAssociatedAudioInputs:                     proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, deviceId: u32, pNumAudioInputs: ^i32, pAudioInputDeviceIDs: ^u32) -> u32,
	GetAssociatedAudioOutputs:                    proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, deviceId: u32, pNumAudioOutputs: ^i32, pAudioOutputDeviceIDs: ^u32) -> u32,
	GetDefaultAudioDevices:                       proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, defaultDeviceID: u32, pNumAudioDevices: ^i32, pAudioDeviceIDs: ^u32) -> u32,
	QuerySampleFormatsSupported:                  proc "c" (self: ^struct {
		using itf: ^SLAudioIODeviceCapabilitiesItf_,
	}, deviceId: u32, samplingRate: u32, pSampleFormats: ^i32, pNumOfSampleFormats: ^i32) -> u32,
}

SLAudioInputDescriptor :: struct {
	deviceName:                  ^u8,
	deviceConnection:            i16,
	deviceScope:                 i16,
	deviceLocation:              i16,
	isForTelephony:              u32,
	minSampleRate:               u32,
	maxSampleRate:               u32,
	isFreqRangeContinuous:       u32,
	samplingRatesSupported:      ^u32,
	numOfSamplingRatesSupported: i16,
	maxChannels:                 i16,
}

SLAudioOutputDescriptor :: struct {
	pDeviceName:                 ^u8,
	deviceConnection:            i16,
	deviceScope:                 i16,
	deviceLocation:              i16,
	isForTelephony:              u32,
	minSampleRate:               u32,
	maxSampleRate:               u32,
	isFreqRangeContinuous:       u32,
	samplingRatesSupported:      ^u32,
	numOfSamplingRatesSupported: i16,
	maxChannels:                 i16,
}

SLAuint64 :: u64

SLBassBoostItf :: ^struct {
	using itf: ^SLBassBoostItf_,
}

SLBassBoostItf_ :: struct {
	SetEnabled:          proc "c" (self: ^struct {
		using itf: ^SLBassBoostItf_,
	}, enabled: u32) -> u32,
	IsEnabled:           proc "c" (self: ^struct {
		using itf: ^SLBassBoostItf_,
	}, pEnabled: ^u32) -> u32,
	SetStrength:         proc "c" (self: ^struct {
		using itf: ^SLBassBoostItf_,
	}, strength: i16) -> u32,
	GetRoundedStrength:  proc "c" (self: ^struct {
		using itf: ^SLBassBoostItf_,
	}, pStrength: ^i16) -> u32,
	IsStrengthSupported: proc "c" (self: ^struct {
		using itf: ^SLBassBoostItf_,
	}, pSupported: ^u32) -> u32,
}

SLBufferQueueItf :: ^struct {
	using itf: ^SLBufferQueueItf_,
}

SLBufferQueueItf_ :: struct {
	Enqueue:          proc "c" (self: ^struct {
		using itf: ^SLBufferQueueItf_,
	}, pBuffer: rawptr, size: u32) -> u32,
	Clear:            proc "c" (self: ^struct {
		using itf: ^SLBufferQueueItf_,
	}) -> u32,
	GetState:         proc "c" (self: ^struct {
		using itf: ^SLBufferQueueItf_,
	}, pState: ^SLBufferQueueState) -> u32,
	RegisterCallback: proc "c" (self: ^struct {
		using itf: ^SLBufferQueueItf_,
	}, callback: slBufferQueueCallback, pContext: rawptr) -> u32,
}

SLBufferQueueState :: struct {
	count:     u32,
	playIndex: u32,
}

SLDataFormat_MIME :: struct {
	formatType:    u32,
	mimeType:      ^u8,
	containerType: u32,
}

SLDataFormat_PCM :: struct {
	formatType:    u32,
	numChannels:   u32,
	samplesPerSec: u32,
	bitsPerSample: u32,
	containerSize: u32,
	channelMask:   u32,
	endianness:    u32,
}

SLDataLocator_Address :: struct {
	locatorType: u32,
	pAddress:    rawptr,
	length:      u32,
}

SLDataLocator_AndroidBufferQueue :: struct {
	locatorType: u32,
	numBuffers:  u32,
}

SLDataLocator_AndroidFD :: struct {
	locatorType: u32,
	fd:          i32,
	offset:      i64,
	length:      i64,
}

SLDataLocator_AndroidSimpleBufferQueue :: struct {
	locatorType: u32,
	numBuffers:  u32,
}

SLDataLocator_BufferQueue :: struct {
	locatorType: u32,
	numBuffers:  u32,
}

SLDataLocator_IODevice :: struct {
	locatorType: u32,
	deviceType:  u32,
	deviceID:    u32,
	device:      ^struct {
		using itf: ^SLObjectItf_,
	},
}

SLDataLocator_MIDIBufferQueue :: struct {
	locatorType: u32,
	tpqn:        u32,
	numBuffers:  u32,
}

SLDataLocator_OutputMix :: struct {
	locatorType: u32,
	outputMix:   ^struct {
		using itf: ^SLObjectItf_,
	},
}

SLDataLocator_URI :: struct {
	locatorType: u32,
	URI:         ^u8,
}

SLDataSink :: struct {
	pLocator: rawptr,
	pFormat:  rawptr,
}

SLDataSource :: struct {
	pLocator: rawptr,
	pFormat:  rawptr,
}

SLDeviceVolumeItf :: ^struct {
	using itf: ^SLDeviceVolumeItf_,
}

SLDeviceVolumeItf_ :: struct {
	GetVolumeScale: proc "c" (self: ^struct {
		using itf: ^SLDeviceVolumeItf_,
	}, deviceID: u32, pMinValue: ^i32, pMaxValue: ^i32, pIsMillibelScale: ^u32) -> u32,
	SetVolume:      proc "c" (self: ^struct {
		using itf: ^SLDeviceVolumeItf_,
	}, deviceID: u32, volume: i32) -> u32,
	GetVolume:      proc "c" (self: ^struct {
		using itf: ^SLDeviceVolumeItf_,
	}, deviceID: u32, pVolume: ^i32) -> u32,
}

SLDynamicInterfaceManagementItf :: ^struct {
	using itf: ^SLDynamicInterfaceManagementItf_,
}

SLDynamicInterfaceManagementItf_ :: struct {
	AddInterface:     proc "c" (self: ^struct {
		using itf: ^SLDynamicInterfaceManagementItf_,
	}, iid: ^SLInterfaceID_, async: u32) -> u32,
	RemoveInterface:  proc "c" (self: ^struct {
		using itf: ^SLDynamicInterfaceManagementItf_,
	}, iid: ^SLInterfaceID_) -> u32,
	ResumeInterface:  proc "c" (self: ^struct {
		using itf: ^SLDynamicInterfaceManagementItf_,
	}, iid: ^SLInterfaceID_, async: u32) -> u32,
	RegisterCallback: proc "c" (self: ^struct {
		using itf: ^SLDynamicInterfaceManagementItf_,
	}, callback: slDynamicInterfaceManagementCallback, pContext: rawptr) -> u32,
}

SLDynamicSourceItf :: ^struct {
	using itf: ^SLDynamicSourceItf_,
}

SLDynamicSourceItf_ :: struct {
	SetSource: proc "c" (self: ^struct {
		using itf: ^SLDynamicSourceItf_,
	}, pDataSource: ^SLDataSource) -> u32,
}

SLEffectSendItf :: ^struct {
	using itf: ^SLEffectSendItf_,
}

SLEffectSendItf_ :: struct {
	EnableEffectSend: proc "c" (self: ^struct {
		using itf: ^SLEffectSendItf_,
	}, pAuxEffect: rawptr, enable: u32, initialLevel: i16) -> u32,
	IsEnabled:        proc "c" (self: ^struct {
		using itf: ^SLEffectSendItf_,
	}, pAuxEffect: rawptr, pEnable: ^u32) -> u32,
	SetDirectLevel:   proc "c" (self: ^struct {
		using itf: ^SLEffectSendItf_,
	}, directLevel: i16) -> u32,
	GetDirectLevel:   proc "c" (self: ^struct {
		using itf: ^SLEffectSendItf_,
	}, pDirectLevel: ^i16) -> u32,
	SetSendLevel:     proc "c" (self: ^struct {
		using itf: ^SLEffectSendItf_,
	}, pAuxEffect: rawptr, sendLevel: i16) -> u32,
	GetSendLevel:     proc "c" (self: ^struct {
		using itf: ^SLEffectSendItf_,
	}, pAuxEffect: rawptr, pSendLevel: ^i16) -> u32,
}

SLEngineCapabilitiesItf :: ^struct {
	using itf: ^SLEngineCapabilitiesItf_,
}

SLEngineCapabilitiesItf_ :: struct {
	QuerySupportedProfiles:        proc "c" (self: ^struct {
		using itf: ^SLEngineCapabilitiesItf_,
	}, pProfilesSupported: ^u16) -> u32,
	QueryAvailableVoices:          proc "c" (self: ^struct {
		using itf: ^SLEngineCapabilitiesItf_,
	}, voiceType: u16, pNumMaxVoices: ^i16, pIsAbsoluteMax: ^u32, pNumFreeVoices: ^i16) -> u32,
	QueryNumberOfMIDISynthesizers: proc "c" (self: ^struct {
		using itf: ^SLEngineCapabilitiesItf_,
	}, pNumMIDIsynthesizers: ^i16) -> u32,
	QueryAPIVersion:               proc "c" (self: ^struct {
		using itf: ^SLEngineCapabilitiesItf_,
	}, pMajor: ^i16, pMinor: ^i16, pStep: ^i16) -> u32,
	QueryLEDCapabilities:          proc "c" (self: ^struct {
		using itf: ^SLEngineCapabilitiesItf_,
	}, pIndex: ^u32, pLEDDeviceID: ^u32, pDescriptor: ^SLLEDDescriptor) -> u32,
	QueryVibraCapabilities:        proc "c" (self: ^struct {
		using itf: ^SLEngineCapabilitiesItf_,
	}, pIndex: ^u32, pVibraDeviceID: ^u32, pDescriptor: ^SLVibraDescriptor) -> u32,
	IsThreadSafe:                  proc "c" (self: ^struct {
		using itf: ^SLEngineCapabilitiesItf_,
	}, pIsThreadSafe: ^u32) -> u32,
}

SLEngineItf :: ^struct {
	using itf: ^SLEngineItf_,
}

SLEngineItf_ :: struct {
	CreateLEDDevice:             proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pDevice: ^^struct {
		using itf: ^SLObjectItf_,
	}, deviceID: u32, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateVibraDevice:           proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pDevice: ^^struct {
		using itf: ^SLObjectItf_,
	}, deviceID: u32, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateAudioPlayer:           proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pPlayer: ^^struct {
		using itf: ^SLObjectItf_,
	}, pAudioSrc: ^SLDataSource, pAudioSnk: ^SLDataSink, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateAudioRecorder:         proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pRecorder: ^^struct {
		using itf: ^SLObjectItf_,
	}, pAudioSrc: ^SLDataSource, pAudioSnk: ^SLDataSink, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateMidiPlayer:            proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pPlayer: ^^struct {
		using itf: ^SLObjectItf_,
	}, pMIDISrc: ^SLDataSource, pBankSrc: ^SLDataSource, pAudioOutput: ^SLDataSink, pVibra: ^SLDataSink, pLEDArray: ^SLDataSink, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateListener:              proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pListener: ^^struct {
		using itf: ^SLObjectItf_,
	}, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	Create3DGroup:               proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pGroup: ^^struct {
		using itf: ^SLObjectItf_,
	}, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateOutputMix:             proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pMix: ^^struct {
		using itf: ^SLObjectItf_,
	}, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateMetadataExtractor:     proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pMetadataExtractor: ^^struct {
		using itf: ^SLObjectItf_,
	}, pDataSource: ^SLDataSource, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateExtensionObject:       proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pObject: ^^struct {
		using itf: ^SLObjectItf_,
	}, pParameters: rawptr, objectID: u32, numInterfaces: u32, pInterfaceIds: ^^SLInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	QueryNumSupportedInterfaces: proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, objectID: u32, pNumSupportedInterfaces: ^u32) -> u32,
	QuerySupportedInterfaces:    proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, objectID: u32, index: u32, pInterfaceId: ^^SLInterfaceID_) -> u32,
	QueryNumSupportedExtensions: proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pNumExtensions: ^u32) -> u32,
	QuerySupportedExtension:     proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, index: u32, pExtensionName: ^u8, pNameLength: ^i16) -> u32,
	IsExtensionSupported:        proc "c" (self: ^struct {
		using itf: ^SLEngineItf_,
	}, pExtensionName: ^u8, pSupported: ^u32) -> u32,
}

SLEngineOption :: struct {
	feature: u32,
	data:    u32,
}

SLEnvironmentalReverbItf :: ^struct {
	using itf: ^SLEnvironmentalReverbItf_,
}

SLEnvironmentalReverbItf_ :: struct {
	SetRoomLevel:                     proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, room: i16) -> u32,
	GetRoomLevel:                     proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pRoom: ^i16) -> u32,
	SetRoomHFLevel:                   proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, roomHF: i16) -> u32,
	GetRoomHFLevel:                   proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pRoomHF: ^i16) -> u32,
	SetDecayTime:                     proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, decayTime: u32) -> u32,
	GetDecayTime:                     proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pDecayTime: ^u32) -> u32,
	SetDecayHFRatio:                  proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, decayHFRatio: i16) -> u32,
	GetDecayHFRatio:                  proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pDecayHFRatio: ^i16) -> u32,
	SetReflectionsLevel:              proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, reflectionsLevel: i16) -> u32,
	GetReflectionsLevel:              proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pReflectionsLevel: ^i16) -> u32,
	SetReflectionsDelay:              proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, reflectionsDelay: u32) -> u32,
	GetReflectionsDelay:              proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pReflectionsDelay: ^u32) -> u32,
	SetReverbLevel:                   proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, reverbLevel: i16) -> u32,
	GetReverbLevel:                   proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pReverbLevel: ^i16) -> u32,
	SetReverbDelay:                   proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, reverbDelay: u32) -> u32,
	GetReverbDelay:                   proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pReverbDelay: ^u32) -> u32,
	SetDiffusion:                     proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, diffusion: i16) -> u32,
	GetDiffusion:                     proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pDiffusion: ^i16) -> u32,
	SetDensity:                       proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, density: i16) -> u32,
	GetDensity:                       proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pDensity: ^i16) -> u32,
	SetEnvironmentalReverbProperties: proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pProperties: ^SLEnvironmentalReverbSettings) -> u32,
	GetEnvironmentalReverbProperties: proc "c" (self: ^struct {
		using itf: ^SLEnvironmentalReverbItf_,
	}, pProperties: ^SLEnvironmentalReverbSettings) -> u32,
}

SLEnvironmentalReverbSettings :: struct {
	roomLevel:        i16,
	roomHFLevel:      i16,
	decayTime:        u32,
	decayHFRatio:     i16,
	reflectionsLevel: i16,
	reflectionsDelay: u32,
	reverbLevel:      i16,
	reverbDelay:      u32,
	diffusion:        i16,
	density:          i16,
}

SLEqualizerItf :: ^struct {
	using itf: ^SLEqualizerItf_,
}

SLEqualizerItf_ :: struct {
	SetEnabled:         proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, enabled: u32) -> u32,
	IsEnabled:          proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, pEnabled: ^u32) -> u32,
	GetNumberOfBands:   proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, pAmount: ^u16) -> u32,
	GetBandLevelRange:  proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, pMin: ^i16, pMax: ^i16) -> u32,
	SetBandLevel:       proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, band: u16, level: i16) -> u32,
	GetBandLevel:       proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, band: u16, pLevel: ^i16) -> u32,
	GetCenterFreq:      proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, band: u16, pCenter: ^u32) -> u32,
	GetBandFreqRange:   proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, band: u16, pMin: ^u32, pMax: ^u32) -> u32,
	GetBand:            proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, frequency: u32, pBand: ^u16) -> u32,
	GetCurrentPreset:   proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, pPreset: ^u16) -> u32,
	UsePreset:          proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, index: u16) -> u32,
	GetNumberOfPresets: proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, pNumPresets: ^u16) -> u32,
	GetPresetName:      proc "c" (self: ^struct {
		using itf: ^SLEqualizerItf_,
	}, index: u16, ppName: ^^u8) -> u32,
}

SLHSL :: struct {
	hue:        i32,
	saturation: i16,
	lightness:  i16,
}

SLInterfaceID :: ^SLInterfaceID_

SLInterfaceID_ :: struct {
	time_low:            u32,
	time_mid:            u16,
	time_hi_and_version: u16,
	clock_seq:           u16,
	node:                [6]u8,
}

SLLEDArrayItf :: ^struct {
	using itf: ^SLLEDArrayItf_,
}

SLLEDArrayItf_ :: struct {
	ActivateLEDArray:    proc "c" (self: ^struct {
		using itf: ^SLLEDArrayItf_,
	}, lightMask: u32) -> u32,
	IsLEDArrayActivated: proc "c" (self: ^struct {
		using itf: ^SLLEDArrayItf_,
	}, lightMask: ^u32) -> u32,
	SetColor:            proc "c" (self: ^struct {
		using itf: ^SLLEDArrayItf_,
	}, index: u8, color: ^SLHSL) -> u32,
	GetColor:            proc "c" (self: ^struct {
		using itf: ^SLLEDArrayItf_,
	}, index: u8, color: ^SLHSL) -> u32,
}

SLLEDDescriptor :: struct {
	ledCount:   u8,
	primaryLED: u8,
	colorMask:  u32,
}

SLMIDIMessageItf :: ^struct {
	using itf: ^SLMIDIMessageItf_,
}

SLMIDIMessageItf_ :: struct {
	SendMessage:                    proc "c" (self: ^struct {
		using itf: ^SLMIDIMessageItf_,
	}, data: ^u8, length: u32) -> u32,
	RegisterMetaEventCallback:      proc "c" (self: ^struct {
		using itf: ^SLMIDIMessageItf_,
	}, callback: slMetaEventCallback, pContext: rawptr) -> u32,
	RegisterMIDIMessageCallback:    proc "c" (self: ^struct {
		using itf: ^SLMIDIMessageItf_,
	}, callback: slMIDIMessageCallback, pContext: rawptr) -> u32,
	AddMIDIMessageCallbackFilter:   proc "c" (self: ^struct {
		using itf: ^SLMIDIMessageItf_,
	}, messageType: u32) -> u32,
	ClearMIDIMessageCallbackFilter: proc "c" (self: ^struct {
		using itf: ^SLMIDIMessageItf_,
	}) -> u32,
}

SLMIDIMuteSoloItf :: ^struct {
	using itf: ^SLMIDIMuteSoloItf_,
}

SLMIDIMuteSoloItf_ :: struct {
	SetChannelMute: proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, channel: u8, mute: u32) -> u32,
	GetChannelMute: proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, channel: u8, pMute: ^u32) -> u32,
	SetChannelSolo: proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, channel: u8, solo: u32) -> u32,
	GetChannelSolo: proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, channel: u8, pSolo: ^u32) -> u32,
	GetTrackCount:  proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, pCount: ^u16) -> u32,
	SetTrackMute:   proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, track: u16, mute: u32) -> u32,
	GetTrackMute:   proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, track: u16, pMute: ^u32) -> u32,
	SetTrackSolo:   proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, track: u16, solo: u32) -> u32,
	GetTrackSolo:   proc "c" (self: ^struct {
		using itf: ^SLMIDIMuteSoloItf_,
	}, track: u16, pSolo: ^u32) -> u32,
}

SLMIDITempoItf :: ^struct {
	using itf: ^SLMIDITempoItf_,
}

SLMIDITempoItf_ :: struct {
	SetTicksPerQuarterNote:        proc "c" (self: ^struct {
		using itf: ^SLMIDITempoItf_,
	}, tpqn: u32) -> u32,
	GetTicksPerQuarterNote:        proc "c" (self: ^struct {
		using itf: ^SLMIDITempoItf_,
	}, pTpqn: ^u32) -> u32,
	SetMicrosecondsPerQuarterNote: proc "c" (self: ^struct {
		using itf: ^SLMIDITempoItf_,
	}, uspqn: u32) -> u32,
	GetMicrosecondsPerQuarterNote: proc "c" (self: ^struct {
		using itf: ^SLMIDITempoItf_,
	}, uspqn: ^u32) -> u32,
}

SLMIDITimeItf :: ^struct {
	using itf: ^SLMIDITimeItf_,
}

SLMIDITimeItf_ :: struct {
	GetDuration:   proc "c" (self: ^struct {
		using itf: ^SLMIDITimeItf_,
	}, pDuration: ^u32) -> u32,
	SetPosition:   proc "c" (self: ^struct {
		using itf: ^SLMIDITimeItf_,
	}, position: u32) -> u32,
	GetPosition:   proc "c" (self: ^struct {
		using itf: ^SLMIDITimeItf_,
	}, pPosition: ^u32) -> u32,
	SetLoopPoints: proc "c" (self: ^struct {
		using itf: ^SLMIDITimeItf_,
	}, startTick: u32, numTicks: u32) -> u32,
	GetLoopPoints: proc "c" (self: ^struct {
		using itf: ^SLMIDITimeItf_,
	}, pStartTick: ^u32, pNumTicks: ^u32) -> u32,
}

SLMetadataExtractionItf :: ^struct {
	using itf: ^SLMetadataExtractionItf_,
}

SLMetadataExtractionItf_ :: struct {
	GetItemCount:   proc "c" (self: ^struct {
		using itf: ^SLMetadataExtractionItf_,
	}, pItemCount: ^u32) -> u32,
	GetKeySize:     proc "c" (self: ^struct {
		using itf: ^SLMetadataExtractionItf_,
	}, index: u32, pKeySize: ^u32) -> u32,
	GetKey:         proc "c" (self: ^struct {
		using itf: ^SLMetadataExtractionItf_,
	}, index: u32, keySize: u32, pKey: ^SLMetadataInfo) -> u32,
	GetValueSize:   proc "c" (self: ^struct {
		using itf: ^SLMetadataExtractionItf_,
	}, index: u32, pValueSize: ^u32) -> u32,
	GetValue:       proc "c" (self: ^struct {
		using itf: ^SLMetadataExtractionItf_,
	}, index: u32, valueSize: u32, pValue: ^SLMetadataInfo) -> u32,
	AddKeyFilter:   proc "c" (self: ^struct {
		using itf: ^SLMetadataExtractionItf_,
	}, keySize: u32, pKey: rawptr, keyEncoding: u32, pValueLangCountry: ^u8, valueEncoding: u32, filterMask: u8) -> u32,
	ClearKeyFilter: proc "c" (self: ^struct {
		using itf: ^SLMetadataExtractionItf_,
	}) -> u32,
}

SLMetadataInfo :: struct {
	size:        u32,
	encoding:    u32,
	langCountry: [16]u8,
	data:        [1]u8,
}

SLMetadataTraversalItf :: ^struct {
	using itf: ^SLMetadataTraversalItf_,
}

SLMetadataTraversalItf_ :: struct {
	SetMode:              proc "c" (self: ^struct {
		using itf: ^SLMetadataTraversalItf_,
	}, mode: u32) -> u32,
	GetChildCount:        proc "c" (self: ^struct {
		using itf: ^SLMetadataTraversalItf_,
	}, pCount: ^u32) -> u32,
	GetChildMIMETypeSize: proc "c" (self: ^struct {
		using itf: ^SLMetadataTraversalItf_,
	}, index: u32, pSize: ^u32) -> u32,
	GetChildInfo:         proc "c" (self: ^struct {
		using itf: ^SLMetadataTraversalItf_,
	}, index: u32, pNodeID: ^i32, pType: ^u32, size: u32, pMimeType: ^u8) -> u32,
	SetActiveNode:        proc "c" (self: ^struct {
		using itf: ^SLMetadataTraversalItf_,
	}, index: u32) -> u32,
}

SLMuteSoloItf :: ^struct {
	using itf: ^SLMuteSoloItf_,
}

SLMuteSoloItf_ :: struct {
	SetChannelMute: proc "c" (self: ^struct {
		using itf: ^SLMuteSoloItf_,
	}, chan: u8, mute: u32) -> u32,
	GetChannelMute: proc "c" (self: ^struct {
		using itf: ^SLMuteSoloItf_,
	}, chan: u8, pMute: ^u32) -> u32,
	SetChannelSolo: proc "c" (self: ^struct {
		using itf: ^SLMuteSoloItf_,
	}, chan: u8, solo: u32) -> u32,
	GetChannelSolo: proc "c" (self: ^struct {
		using itf: ^SLMuteSoloItf_,
	}, chan: u8, pSolo: ^u32) -> u32,
	GetNumChannels: proc "c" (self: ^struct {
		using itf: ^SLMuteSoloItf_,
	}, pNumChannels: ^u8) -> u32,
}

SLObjectItf :: ^struct {
	using itf: ^SLObjectItf_,
}

SLObjectItf_ :: struct {
	Realize:                    proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, async: u32) -> u32,
	Resume:                     proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, async: u32) -> u32,
	GetState:                   proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, pState: ^u32) -> u32,
	GetInterface:               proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, iid: ^SLInterfaceID_, pInterface: rawptr) -> u32,
	RegisterCallback:           proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, callback: slObjectCallback, pContext: rawptr) -> u32,
	AbortAsyncOperation:        proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}),
	Destroy:                    proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}),
	SetPriority:                proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, priority: i32, preemptable: u32) -> u32,
	GetPriority:                proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, pPriority: ^i32, pPreemptable: ^u32) -> u32,
	SetLossOfControlInterfaces: proc "c" (self: ^struct {
		using itf: ^SLObjectItf_,
	}, numInterfaces: i16, pInterfaceIDs: ^^SLInterfaceID_, enabled: u32) -> u32,
}

SLOutputMixItf :: ^struct {
	using itf: ^SLOutputMixItf_,
}

SLOutputMixItf_ :: struct {
	GetDestinationOutputDeviceIDs: proc "c" (self: ^struct {
		using itf: ^SLOutputMixItf_,
	}, pNumDevices: ^i32, pDeviceIDs: ^u32) -> u32,
	RegisterDeviceChangeCallback:  proc "c" (self: ^struct {
		using itf: ^SLOutputMixItf_,
	}, callback: slMixDeviceChangeCallback, pContext: rawptr) -> u32,
	ReRoute:                       proc "c" (self: ^struct {
		using itf: ^SLOutputMixItf_,
	}, numOutputDevices: i32, pOutputDeviceIDs: ^u32) -> u32,
}

SLPitchItf :: ^struct {
	using itf: ^SLPitchItf_,
}

SLPitchItf_ :: struct {
	SetPitch:             proc "c" (self: ^struct {
		using itf: ^SLPitchItf_,
	}, pitch: i16) -> u32,
	GetPitch:             proc "c" (self: ^struct {
		using itf: ^SLPitchItf_,
	}, pPitch: ^i16) -> u32,
	GetPitchCapabilities: proc "c" (self: ^struct {
		using itf: ^SLPitchItf_,
	}, pMinPitch: ^i16, pMaxPitch: ^i16) -> u32,
}

SLPlayItf :: ^struct {
	using itf: ^SLPlayItf_,
}

SLPlayItf_ :: struct {
	SetPlayState:            proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, state: u32) -> u32,
	GetPlayState:            proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, pState: ^u32) -> u32,
	GetDuration:             proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, pMsec: ^u32) -> u32,
	GetPosition:             proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, pMsec: ^u32) -> u32,
	RegisterCallback:        proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, callback: slPlayCallback, pContext: rawptr) -> u32,
	SetCallbackEventsMask:   proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, eventFlags: u32) -> u32,
	GetCallbackEventsMask:   proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, pEventFlags: ^u32) -> u32,
	SetMarkerPosition:       proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, mSec: u32) -> u32,
	ClearMarkerPosition:     proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}) -> u32,
	GetMarkerPosition:       proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, pMsec: ^u32) -> u32,
	SetPositionUpdatePeriod: proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, mSec: u32) -> u32,
	GetPositionUpdatePeriod: proc "c" (self: ^struct {
		using itf: ^SLPlayItf_,
	}, pMsec: ^u32) -> u32,
}

SLPlaybackRateItf :: ^struct {
	using itf: ^SLPlaybackRateItf_,
}

SLPlaybackRateItf_ :: struct {
	SetRate:                proc "c" (self: ^struct {
		using itf: ^SLPlaybackRateItf_,
	}, rate: i16) -> u32,
	GetRate:                proc "c" (self: ^struct {
		using itf: ^SLPlaybackRateItf_,
	}, pRate: ^i16) -> u32,
	SetPropertyConstraints: proc "c" (self: ^struct {
		using itf: ^SLPlaybackRateItf_,
	}, constraints: u32) -> u32,
	GetProperties:          proc "c" (self: ^struct {
		using itf: ^SLPlaybackRateItf_,
	}, pProperties: ^u32) -> u32,
	GetCapabilitiesOfRate:  proc "c" (self: ^struct {
		using itf: ^SLPlaybackRateItf_,
	}, rate: i16, pCapabilities: ^u32) -> u32,
	GetRateRange:           proc "c" (self: ^struct {
		using itf: ^SLPlaybackRateItf_,
	}, index: u8, pMinRate: ^i16, pMaxRate: ^i16, pStepSize: ^i16, pCapabilities: ^u32) -> u32,
}

SLPrefetchStatusItf :: ^struct {
	using itf: ^SLPrefetchStatusItf_,
}

SLPrefetchStatusItf_ :: struct {
	GetPrefetchStatus:     proc "c" (self: ^struct {
		using itf: ^SLPrefetchStatusItf_,
	}, pStatus: ^u32) -> u32,
	GetFillLevel:          proc "c" (self: ^struct {
		using itf: ^SLPrefetchStatusItf_,
	}, pLevel: ^i16) -> u32,
	RegisterCallback:      proc "c" (self: ^struct {
		using itf: ^SLPrefetchStatusItf_,
	}, callback: slPrefetchCallback, pContext: rawptr) -> u32,
	SetCallbackEventsMask: proc "c" (self: ^struct {
		using itf: ^SLPrefetchStatusItf_,
	}, eventFlags: u32) -> u32,
	GetCallbackEventsMask: proc "c" (self: ^struct {
		using itf: ^SLPrefetchStatusItf_,
	}, pEventFlags: ^u32) -> u32,
	SetFillUpdatePeriod:   proc "c" (self: ^struct {
		using itf: ^SLPrefetchStatusItf_,
	}, period: i16) -> u32,
	GetFillUpdatePeriod:   proc "c" (self: ^struct {
		using itf: ^SLPrefetchStatusItf_,
	}, pPeriod: ^i16) -> u32,
}

SLPresetReverbItf :: ^struct {
	using itf: ^SLPresetReverbItf_,
}

SLPresetReverbItf_ :: struct {
	SetPreset: proc "c" (self: ^struct {
		using itf: ^SLPresetReverbItf_,
	}, preset: u16) -> u32,
	GetPreset: proc "c" (self: ^struct {
		using itf: ^SLPresetReverbItf_,
	}, pPreset: ^u16) -> u32,
}

SLRatePitchItf :: ^struct {
	using itf: ^SLRatePitchItf_,
}

SLRatePitchItf_ :: struct {
	SetRate:                  proc "c" (self: ^struct {
		using itf: ^SLRatePitchItf_,
	}, rate: i16) -> u32,
	GetRate:                  proc "c" (self: ^struct {
		using itf: ^SLRatePitchItf_,
	}, pRate: ^i16) -> u32,
	GetRatePitchCapabilities: proc "c" (self: ^struct {
		using itf: ^SLRatePitchItf_,
	}, pMinRate: ^i16, pMaxRate: ^i16) -> u32,
}

SLRecordItf :: ^struct {
	using itf: ^SLRecordItf_,
}

SLRecordItf_ :: struct {
	SetRecordState:          proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, state: u32) -> u32,
	GetRecordState:          proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, pState: ^u32) -> u32,
	SetDurationLimit:        proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, msec: u32) -> u32,
	GetPosition:             proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, pMsec: ^u32) -> u32,
	RegisterCallback:        proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, callback: slRecordCallback, pContext: rawptr) -> u32,
	SetCallbackEventsMask:   proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, eventFlags: u32) -> u32,
	GetCallbackEventsMask:   proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, pEventFlags: ^u32) -> u32,
	SetMarkerPosition:       proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, mSec: u32) -> u32,
	ClearMarkerPosition:     proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}) -> u32,
	GetMarkerPosition:       proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, pMsec: ^u32) -> u32,
	SetPositionUpdatePeriod: proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, mSec: u32) -> u32,
	GetPositionUpdatePeriod: proc "c" (self: ^struct {
		using itf: ^SLRecordItf_,
	}, pMsec: ^u32) -> u32,
}

SLSeekItf :: ^struct {
	using itf: ^SLSeekItf_,
}

SLSeekItf_ :: struct {
	SetPosition: proc "c" (self: ^struct {
		using itf: ^SLSeekItf_,
	}, pos: u32, seekMode: u32) -> u32,
	SetLoop:     proc "c" (self: ^struct {
		using itf: ^SLSeekItf_,
	}, loopEnable: u32, startPos: u32, endPos: u32) -> u32,
	GetLoop:     proc "c" (self: ^struct {
		using itf: ^SLSeekItf_,
	}, pLoopEnabled: ^u32, pStartPos: ^u32, pEndPos: ^u32) -> u32,
}

SLThreadSyncItf :: ^struct {
	using itf: ^SLThreadSyncItf_,
}

SLThreadSyncItf_ :: struct {
	EnterCriticalSection: proc "c" (self: ^struct {
		using itf: ^SLThreadSyncItf_,
	}) -> u32,
	ExitCriticalSection:  proc "c" (self: ^struct {
		using itf: ^SLThreadSyncItf_,
	}) -> u32,
}

SLVec3D :: struct {
	x: i32,
	y: i32,
	z: i32,
}

SLVibraDescriptor :: struct {
	supportsFrequency: u32,
	supportsIntensity: u32,
	minFrequency:      u32,
	maxFrequency:      u32,
}

SLVibraItf :: ^struct {
	using itf: ^SLVibraItf_,
}

SLVibraItf_ :: struct {
	Vibrate:      proc "c" (self: ^struct {
		using itf: ^SLVibraItf_,
	}, vibrate: u32) -> u32,
	IsVibrating:  proc "c" (self: ^struct {
		using itf: ^SLVibraItf_,
	}, pVibrating: ^u32) -> u32,
	SetFrequency: proc "c" (self: ^struct {
		using itf: ^SLVibraItf_,
	}, frequency: u32) -> u32,
	GetFrequency: proc "c" (self: ^struct {
		using itf: ^SLVibraItf_,
	}, pFrequency: ^u32) -> u32,
	SetIntensity: proc "c" (self: ^struct {
		using itf: ^SLVibraItf_,
	}, intensity: i16) -> u32,
	GetIntensity: proc "c" (self: ^struct {
		using itf: ^SLVibraItf_,
	}, pIntensity: ^i16) -> u32,
}

SLVirtualizerItf :: ^struct {
	using itf: ^SLVirtualizerItf_,
}

SLVirtualizerItf_ :: struct {
	SetEnabled:          proc "c" (self: ^struct {
		using itf: ^SLVirtualizerItf_,
	}, enabled: u32) -> u32,
	IsEnabled:           proc "c" (self: ^struct {
		using itf: ^SLVirtualizerItf_,
	}, pEnabled: ^u32) -> u32,
	SetStrength:         proc "c" (self: ^struct {
		using itf: ^SLVirtualizerItf_,
	}, strength: i16) -> u32,
	GetRoundedStrength:  proc "c" (self: ^struct {
		using itf: ^SLVirtualizerItf_,
	}, pStrength: ^i16) -> u32,
	IsStrengthSupported: proc "c" (self: ^struct {
		using itf: ^SLVirtualizerItf_,
	}, pSupported: ^u32) -> u32,
}

SLVisualizationItf :: ^struct {
	using itf: ^SLVisualizationItf_,
}

SLVisualizationItf_ :: struct {
	RegisterVisualizationCallback: proc "c" (self: ^struct {
		using itf: ^SLVisualizationItf_,
	}, callback: slVisualizationCallback, pContext: rawptr, rate: u32) -> u32,
	GetMaxRate:                    proc "c" (self: ^struct {
		using itf: ^SLVisualizationItf_,
	}, pRate: ^u32) -> u32,
}

SLVolumeItf :: ^struct {
	using itf: ^SLVolumeItf_,
}

SLVolumeItf_ :: struct {
	SetVolumeLevel:          proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, level: i16) -> u32,
	GetVolumeLevel:          proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, pLevel: ^i16) -> u32,
	GetMaxVolumeLevel:       proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, pMaxLevel: ^i16) -> u32,
	SetMute:                 proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, mute: u32) -> u32,
	GetMute:                 proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, pMute: ^u32) -> u32,
	EnableStereoPosition:    proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, enable: u32) -> u32,
	IsEnabledStereoPosition: proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, pEnable: ^u32) -> u32,
	SetStereoPosition:       proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, stereoPosition: i16) -> u32,
	GetStereoPosition:       proc "c" (self: ^struct {
		using itf: ^SLVolumeItf_,
	}, pStereoPosition: ^i16) -> u32,
}

SLboolean :: u32

SLchar :: u8

SLint16 :: i16

SLint32 :: i32

SLint8 :: i8

SLmicrosecond :: u32

SLmilliHertz :: u32

SLmillibel :: i16

SLmillidegree :: i32

SLmillimeter :: i32

SLmillisecond :: u32

SLpermille :: i16

SLresult :: u32

SLuint16 :: u16

SLuint32 :: u32

SLuint8 :: u8

slAndroidBufferQueueCallback :: proc "c" (caller: ^struct {
	using itf: ^SLAndroidBufferQueueItf_,
}, pCallbackContext: rawptr, pBufferContext: rawptr, pBufferData: rawptr, dataSize: u32, dataUsed: u32, pItems: ^SLAndroidBufferItem, itemsLength: u32) -> u32

slAndroidSimpleBufferQueueCallback :: proc "c" (caller: ^struct {
	using itf: ^SLAndroidSimpleBufferQueueItf_,
}, pContext: rawptr)

slAvailableAudioInputsChangedCallback :: proc "c" (caller: ^struct {
	using itf: ^SLAudioIODeviceCapabilitiesItf_,
}, pContext: rawptr, deviceID: u32, numInputs: i32, isNew: u32)

slAvailableAudioOutputsChangedCallback :: proc "c" (caller: ^struct {
	using itf: ^SLAudioIODeviceCapabilitiesItf_,
}, pContext: rawptr, deviceID: u32, numOutputs: i32, isNew: u32)

slBufferQueueCallback :: proc "c" (caller: ^struct {
	using itf: ^SLBufferQueueItf_,
}, pContext: rawptr)

slDefaultDeviceIDMapChangedCallback :: proc "c" (caller: ^struct {
	using itf: ^SLAudioIODeviceCapabilitiesItf_,
}, pContext: rawptr, isOutput: u32, numDevices: i32)

slDynamicInterfaceManagementCallback :: proc "c" (caller: ^struct {
	using itf: ^SLDynamicInterfaceManagementItf_,
}, pContext: rawptr, event: u32, result: u32, iid: ^SLInterfaceID_)

slMIDIMessageCallback :: proc "c" (caller: ^struct {
	using itf: ^SLMIDIMessageItf_,
}, pContext: rawptr, statusByte: u8, length: u32, pData: ^u8, tick: u32, track: u16)

slMetaEventCallback :: proc "c" (caller: ^struct {
	using itf: ^SLMIDIMessageItf_,
}, pContext: rawptr, type: u8, length: u32, pData: ^u8, tick: u32, track: u16)

slMixDeviceChangeCallback :: proc "c" (caller: ^struct {
	using itf: ^SLOutputMixItf_,
}, pContext: rawptr)

slObjectCallback :: proc "c" (caller: ^struct {
	using itf: ^SLObjectItf_,
}, pContext: rawptr, event: u32, result: u32, param: u32, pInterface: rawptr)

slPlayCallback :: proc "c" (caller: ^struct {
	using itf: ^SLPlayItf_,
}, pContext: rawptr, event: u32)

slPrefetchCallback :: proc "c" (caller: ^struct {
	using itf: ^SLPrefetchStatusItf_,
}, pContext: rawptr, event: u32)

slRecordCallback :: proc "c" (caller: ^struct {
	using itf: ^SLRecordItf_,
}, pContext: rawptr, event: u32)

slVisualizationCallback :: proc "c" (rawptr, ^u8, ^u8, u32)

sl_int16_t :: i16

sl_int32_t :: i32

sl_int64_t :: i64

sl_int8_t :: i8

sl_uint16_t :: u16

sl_uint32_t :: u32

sl_uint64_t :: u64

sl_uint8_t :: u8

ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE :: "AndroidPcmFormatBitsPerSample"

ANDROID_KEY_PCMFORMAT_CHANNELMASK :: "AndroidPcmFormatChannelMask"

ANDROID_KEY_PCMFORMAT_CONTAINERSIZE :: "AndroidPcmFormatContainerSize"

ANDROID_KEY_PCMFORMAT_ENDIANNESS :: "AndroidPcmFormatEndianness"

ANDROID_KEY_PCMFORMAT_NUMCHANNELS :: "AndroidPcmFormatNumChannels"

ANDROID_KEY_PCMFORMAT_SAMPLERATE :: "AndroidPcmFormatSampleRate"

KHRONOS_ALBUM :: "KhronosAlbum"

KHRONOS_ALBUM_ART :: "KhronosAlbumArt"

KHRONOS_ARTIST :: "KhronosArtist"

KHRONOS_ARTIST_URL :: "KhronosArtistURL"

KHRONOS_COMMENT :: "KhronosComment"

KHRONOS_CONTENT_URL :: "KhronosContentURL"

KHRONOS_COPYRIGHT :: "KhronosCopyright"

KHRONOS_GENRE :: "KhronosGenre"

KHRONOS_RATING :: "KhronosRating"

KHRONOS_TITLE :: "KhronosTitle"

KHRONOS_TRACK_NUMBER :: "KhronosTrackNumber"

KHRONOS_YEAR :: "KhronosYear"

SL_ANDROIDBUFFERQUEUEEVENT_NONE :: 0x0

SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED :: 0x1

SL_ANDROID_DATAFORMAT_PCM_EX :: 0x4

SL_ANDROID_ITEMKEY_BUFFERQUEUEEVENT :: 0x3

SL_ANDROID_ITEMKEY_DISCONTINUITY :: 0x2

SL_ANDROID_ITEMKEY_EOS :: 0x1

SL_ANDROID_ITEMKEY_FORMAT_CHANGE :: 0x4

SL_ANDROID_ITEMKEY_NONE :: 0x0

SL_ANDROID_JAVA_PROXY_ROUTING :: 0x0001

SL_ANDROID_PCM_REPRESENTATION_FLOAT :: 0x3

SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT :: 0x1

SL_ANDROID_PCM_REPRESENTATION_UNSIGNED_INT :: 0x2

SL_ANDROID_PERFORMANCE_LATENCY :: 0x1

SL_ANDROID_PERFORMANCE_LATENCY_EFFECTS :: 0x2

SL_ANDROID_PERFORMANCE_NONE :: 0x0

SL_ANDROID_PERFORMANCE_POWER_SAVING :: 0x3

SL_ANDROID_RECORDING_PRESET_CAMCORDER :: 0x2

SL_ANDROID_RECORDING_PRESET_GENERIC :: 0x1

SL_ANDROID_RECORDING_PRESET_NONE :: 0x0

SL_ANDROID_RECORDING_PRESET_UNPROCESSED :: 0x5

SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION :: 0x4

SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION :: 0x3

SL_ANDROID_SPEAKER_NON_POSITIONAL :: 0x80000000

SL_ANDROID_SPEAKER_USE_DEFAULT :: 0

SL_ANDROID_STREAM_ALARM :: 0x4

SL_ANDROID_STREAM_MEDIA :: 0x3

SL_ANDROID_STREAM_NOTIFICATION :: 0x5

SL_ANDROID_STREAM_RING :: 0x2

SL_ANDROID_STREAM_SYSTEM :: 0x1

SL_ANDROID_STREAM_VOICE :: 0x0

SL_AUDIOCHANMODE_MP3_DUAL :: 0x4

SL_AUDIOCHANMODE_MP3_JOINTSTEREO :: 0x3

SL_AUDIOCHANMODE_MP3_MONO :: 0x1

SL_AUDIOCHANMODE_MP3_STEREO :: 0x2

SL_AUDIOCODEC_AAC :: 0x6

SL_AUDIOCODEC_AMR :: 0x3

SL_AUDIOCODEC_AMRWB :: 0x4

SL_AUDIOCODEC_AMRWBPLUS :: 0x5

SL_AUDIOCODEC_MP3 :: 0x2

SL_AUDIOCODEC_PCM :: 0x1

SL_AUDIOCODEC_REAL :: 0x8

SL_AUDIOCODEC_WMA :: 0x7

SL_AUDIOMODE_AAC_ERLC :: 0x7

SL_AUDIOMODE_AAC_HE :: 0x5

SL_AUDIOMODE_AAC_HE_MPS :: 0xa

SL_AUDIOMODE_AAC_HE_PS :: 0x9

SL_AUDIOMODE_AAC_LC :: 0x2

SL_AUDIOMODE_AAC_LD :: 0x8

SL_AUDIOMODE_AAC_LTP :: 0x4

SL_AUDIOMODE_AAC_MAIN :: 0x1

SL_AUDIOMODE_AAC_SCALABLE :: 0x6

SL_AUDIOMODE_AAC_SSR :: 0x3

SL_AUDIOMODE_REALAUDIO_10 :: 0x3

SL_AUDIOMODE_REALAUDIO_8 :: 0x2

SL_AUDIOMODE_REALAUDIO_G2 :: 0x1

SL_AUDIOMODE_REALAUDIO_SURROUND :: 0x4

SL_AUDIOMODE_WMAPRO_LEVELM0 :: 0x5