package vendor:android/openmaxal

Source

XAAint64 :: i64

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

XAAndroidBufferQueueItf :: ^struct {
	using itf: ^XAAndroidBufferQueueItf_,
}

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

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

XAAudioCodecDescriptor :: 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,
}

XAAudioDecoderCapabilitiesItf :: ^struct {
	using itf: ^XAAudioDecoderCapabilitiesItf_,
}

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

XAAudioEncoderCapabilitiesItf :: ^struct {
	using itf: ^XAAudioEncoderCapabilitiesItf_,
}

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

XAAudioEncoderItf :: ^struct {
	using itf: ^XAAudioEncoderItf_,
}

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

XAAudioEncoderSettings :: 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,
}

XAAudioIODeviceCapabilitiesItf :: ^struct {
	using itf: ^XAAudioIODeviceCapabilitiesItf_,
}

XAAudioIODeviceCapabilitiesItf_ :: struct {
	GetAvailableAudioInputs:                      proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, pNumInputs: ^i32, pInputDeviceIDs: ^u32) -> u32,
	QueryAudioInputCapabilities:                  proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, deviceID: u32, pDescriptor: ^XAAudioInputDescriptor) -> u32,
	RegisterAvailableAudioInputsChangedCallback:  proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, callback: xaAvailableAudioInputsChangedCallback, pContext: rawptr) -> u32,
	GetAvailableAudioOutputs:                     proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, pNumOutputs: ^i32, pOutputDeviceIDs: ^u32) -> u32,
	QueryAudioOutputCapabilities:                 proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, deviceID: u32, pDescriptor: ^XAAudioOutputDescriptor) -> u32,
	RegisterAvailableAudioOutputsChangedCallback: proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, callback: xaAvailableAudioOutputsChangedCallback, pContext: rawptr) -> u32,
	RegisterDefaultDeviceIDMapChangedCallback:    proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, callback: xaDefaultDeviceIDMapChangedCallback, pContext: rawptr) -> u32,
	GetAssociatedAudioInputs:                     proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, deviceID: u32, pNumAudioInputs: ^i32, pAudioInputDeviceIDs: ^u32) -> u32,
	GetAssociatedAudioOutputs:                    proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, deviceID: u32, pNumAudioOutputs: ^i32, pAudioOutputDeviceIDs: ^u32) -> u32,
	GetDefaultAudioDevices:                       proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, defaultDeviceID: u32, pNumAudioDevices: ^i32, pAudioDeviceIDs: ^u32) -> u32,
	QuerySampleFormatsSupported:                  proc "c" (self: ^struct {
		using itf: ^XAAudioIODeviceCapabilitiesItf_,
	}, deviceID: u32, samplingRate: u32, pSampleFormats: ^i32, pNumOfSampleFormats: ^i32) -> u32,
}

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

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

XAAudioStreamInformation :: struct {
	codecId:     u32,
	channels:    u32,
	sampleRate:  u32,
	bitRate:     u32,
	langCountry: [16]u8,
	duration:    u32,
}

XAAuint64 :: u64

XACameraCapabilitiesItf :: ^struct {
	using itf: ^XACameraCapabilitiesItf_,
}

XACameraCapabilitiesItf_ :: struct {
	GetCameraCapabilities:                  proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, pIndex: ^u32, pCameraDeviceID: ^u32, pDescriptor: ^XACameraDescriptor) -> u32,
	QueryFocusRegionPatterns:               proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, pPatternID: ^u32, pFocusPattern: ^u32, pCustomPoints1: ^u32, pCustomPoints2: ^u32) -> u32,
	GetSupportedAutoLocks:                  proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, pNumCombinations: ^u32, ppLocks: ^^u32) -> u32,
	GetSupportedFocusManualSettings:        proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, macroEnabled: u32, pMinValue: ^i32, pMaxValue: ^i32, pNumSettings: ^u32, ppSettings: ^^i32) -> u32,
	GetSupportedISOSensitivitySettings:     proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, pMinValue: ^u32, pMaxValue: ^u32, pNumSettings: ^u32, ppSettings: ^^u32) -> u32,
	GetSupportedApertureManualSettings:     proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, pMinValue: ^u32, pMaxValue: ^u32, pNumSettings: ^u32, ppSettings: ^^u32) -> u32,
	GetSupportedShutterSpeedManualSettings: proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, pMinValue: ^u32, pMaxValue: ^u32, pNumSettings: ^u32, ppSettings: ^^u32) -> u32,
	GetSupportedWhiteBalanceManualSettings: proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, pMinValue: ^u32, pMaxValue: ^u32, pNumSettings: ^u32, ppSettings: ^^u32) -> u32,
	GetSupportedZoomSettings:               proc "c" (self: ^struct {
		using itf: ^XACameraCapabilitiesItf_,
	}, cameraDeviceID: u32, digitalEnabled: u32, macroEnabled: u32, pMaxValue: ^i16, pNumSettings: ^u32, ppSettings: ^^i16, pSpeedSupported: ^u32) -> u32,
}

XACameraDescriptor :: struct {
	name:                       ^u8,
	maxWidth:                   u32,
	maxHeight:                  u32,
	orientation:                u32,
	featuresSupported:          u32,
	exposureModesSupported:     u32,
	flashModesSupported:        u32,
	focusModesSupported:        u32,
	meteringModesSupported:     u32,
	whiteBalanceModesSupported: u32,
}

XACameraItf :: ^struct {
	using itf: ^XACameraItf_,
}

XACameraItf_ :: struct {
	RegisterCallback:        proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, callback: xaCameraCallback, pContext: rawptr) -> u32,
	SetFlashMode:            proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, flashMode: u32) -> u32,
	GetFlashMode:            proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pFlashMode: ^u32) -> u32,
	IsFlashReady:            proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pReady: ^u32) -> u32,
	SetFocusMode:            proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, focusMode: u32, manualSetting: i32, macroEnabled: u32) -> u32,
	GetFocusMode:            proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pFocusMode: ^u32, pManualSetting: ^i32, pMacroEnabled: ^u32) -> u32,
	SetFocusRegionPattern:   proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, focusPattern: u32, activePoints1: u32, activePoints2: u32) -> u32,
	GetFocusRegionPattern:   proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pFocusPattern: ^u32, pActivePoints1: ^u32, pActivePoints2: ^u32) -> u32,
	GetFocusRegionPositions: proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pNumPositionEntries: ^u32, pFocusPosition: ^XAFocusPointPosition) -> u32,
	GetFocusModeStatus:      proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pFocusStatus: ^u32, pRegionStatus1: ^u32, pRegionStatus2: ^u32) -> u32,
	SetMeteringMode:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, meteringMode: u32) -> u32,
	GetMeteringMode:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pMeteringMode: ^u32) -> u32,
	SetExposureMode:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, exposure: u32, compensation: u32) -> u32,
	GetExposureMode:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pExposure: ^u32, pCompensation: ^u32) -> u32,
	SetISOSensitivity:       proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, isoSensitivity: u32, manualSetting: u32) -> u32,
	GetISOSensitivity:       proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pIsoSensitivity: ^u32, pManualSetting: ^u32) -> u32,
	SetAperture:             proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, aperture: u32, manualSetting: u32) -> u32,
	GetAperture:             proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pAperture: ^u32, pManualSetting: ^u32) -> u32,
	SetShutterSpeed:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, shutterSpeed: u32, manualSetting: u32) -> u32,
	GetShutterSpeed:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pShutterSpeed: ^u32, pManualSetting: ^u32) -> u32,
	SetWhiteBalance:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, whiteBalance: u32, manualSetting: u32) -> u32,
	GetWhiteBalance:         proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pWhiteBalance: ^u32, pManualSetting: ^u32) -> u32,
	SetAutoLocks:            proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, locks: u32) -> u32,
	GetAutoLocks:            proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, locks: ^u32) -> u32,
	SetZoom:                 proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, zoom: i16, digitalEnabled: u32, speed: u32, async: u32) -> u32,
	GetZoom:                 proc "c" (self: ^struct {
		using itf: ^XACameraItf_,
	}, pZoom: ^i16, pDigital: ^u32) -> u32,
}

XAConfigExtensionsItf :: ^struct {
	using itf: ^XAConfigExtensionsItf_,
}

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

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

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

XADataFormat_RawImage :: struct {
	formatType:  u32,
	colorFormat: u32,
	height:      u32,
	width:       u32,
	stride:      u32,
}

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

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

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

XADataLocator_IODevice :: struct {
	locatorType: u32,
	deviceType:  u32,
	deviceID:    u32,
	device:      ^struct {
		using itf: ^XAObjectItf_,
	},
}

XADataLocator_NativeDisplay :: struct {
	locatorType: u32,
	hWindow:     rawptr,
	hDisplay:    rawptr,
}

XADataLocator_OutputMix :: struct {
	locatorType: u32,
	outputMix:   ^struct {
		using itf: ^XAObjectItf_,
	},
}

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

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

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

XADeviceVolumeItf :: ^struct {
	using itf: ^XADeviceVolumeItf_,
}

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

XADynamicInterfaceManagementItf :: ^struct {
	using itf: ^XADynamicInterfaceManagementItf_,
}

XADynamicInterfaceManagementItf_ :: struct {
	AddInterface:     proc "c" (self: ^struct {
		using itf: ^XADynamicInterfaceManagementItf_,
	}, iid: ^XAInterfaceID_, aysnc: u32) -> u32,
	RemoveInterface:  proc "c" (self: ^struct {
		using itf: ^XADynamicInterfaceManagementItf_,
	}, iid: ^XAInterfaceID_) -> u32,
	ResumeInterface:  proc "c" (self: ^struct {
		using itf: ^XADynamicInterfaceManagementItf_,
	}, iid: ^XAInterfaceID_, aysnc: u32) -> u32,
	RegisterCallback: proc "c" (self: ^struct {
		using itf: ^XADynamicInterfaceManagementItf_,
	}, callback: xaDynamicInterfaceManagementCallback, pContext: rawptr) -> u32,
}

XADynamicSourceItf :: ^struct {
	using itf: ^XADynamicSourceItf_,
}

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

XAEngineItf :: ^struct {
	using itf: ^XAEngineItf_,
}

XAEngineItf_ :: struct {
	CreateCameraDevice:          proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pDevice: ^^struct {
		using itf: ^XAObjectItf_,
	}, deviceID: u32, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateRadioDevice:           proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pDevice: ^^struct {
		using itf: ^XAObjectItf_,
	}, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateLEDDevice:             proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pDevice: ^^struct {
		using itf: ^XAObjectItf_,
	}, deviceID: u32, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateVibraDevice:           proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pDevice: ^^struct {
		using itf: ^XAObjectItf_,
	}, deviceID: u32, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateMediaPlayer:           proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pPlayer: ^^struct {
		using itf: ^XAObjectItf_,
	}, pDataSrc: ^XADataSource, pBankSrc: ^XADataSource, pAudioSnk: ^XADataSink, pImageVideoSnk: ^XADataSink, pVibra: ^XADataSink, pLEDArray: ^XADataSink, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateMediaRecorder:         proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pRecorder: ^^struct {
		using itf: ^XAObjectItf_,
	}, pAudioSrc: ^XADataSource, pImageVideoSrc: ^XADataSource, pDataSnk: ^XADataSink, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateOutputMix:             proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pMix: ^^struct {
		using itf: ^XAObjectItf_,
	}, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateMetadataExtractor:     proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pMetadataExtractor: ^^struct {
		using itf: ^XAObjectItf_,
	}, pDataSource: ^XADataSource, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	CreateExtensionObject:       proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pObject: ^^struct {
		using itf: ^XAObjectItf_,
	}, pParameters: rawptr, objectID: u32, numInterfaces: u32, pInterfaceIds: ^^XAInterfaceID_, pInterfaceRequired: ^u32) -> u32,
	GetImplementationInfo:       proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pMajor: ^u32, pMinor: ^u32, pStep: ^u32, pImplementationText: ^u8) -> u32,
	QuerySupportedProfiles:      proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pProfilesSupported: ^i16) -> u32,
	QueryNumSupportedInterfaces: proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, objectID: u32, pNumSupportedInterfaces: ^u32) -> u32,
	QuerySupportedInterfaces:    proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, objectID: u32, index: u32, pInterfaceId: ^^XAInterfaceID_) -> u32,
	QueryNumSupportedExtensions: proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pNumExtensions: ^u32) -> u32,
	QuerySupportedExtension:     proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, index: u32, pExtensionName: ^u8, pNameLength: ^i16) -> u32,
	IsExtensionSupported:        proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pExtensionName: ^u8, pSupported: ^u32) -> u32,
	QueryLEDCapabilities:        proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pIndex: ^u32, pLEDDeviceID: ^u32, pDescriptor: ^XALEDDescriptor) -> u32,
	QueryVibraCapabilities:      proc "c" (self: ^struct {
		using itf: ^XAEngineItf_,
	}, pIndex: ^u32, pVibraDeviceID: ^u32, pDescriptor: ^XAVibraDescriptor) -> u32,
}

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

XAEqualizerItf :: ^struct {
	using itf: ^XAEqualizerItf_,
}

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

XAFocusPointPosition :: struct {
	left:   u32,
	top:    u32,
	width:  u32,
	height: u32,
}

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

XAImageCodecDescriptor :: struct {
	codecId:   u32,
	maxWidth:  u32,
	maxHeight: u32,
}

XAImageControlsItf :: ^struct {
	using itf: ^XAImageControlsItf_,
}

XAImageControlsItf_ :: struct {
	SetBrightness:             proc "c" (self: ^struct {
		using itf: ^XAImageControlsItf_,
	}, brightness: u32) -> u32,
	GetBrightness:             proc "c" (self: ^struct {
		using itf: ^XAImageControlsItf_,
	}, pBrightness: ^u32) -> u32,
	SetContrast:               proc "c" (self: ^struct {
		using itf: ^XAImageControlsItf_,
	}, contrast: i32) -> u32,
	GetContrast:               proc "c" (self: ^struct {
		using itf: ^XAImageControlsItf_,
	}, pContrast: ^i32) -> u32,
	SetGamma:                  proc "c" (self: ^struct {
		using itf: ^XAImageControlsItf_,
	}, gamma: i16) -> u32,
	GetGamma:                  proc "c" (self: ^struct {
		using itf: ^XAImageControlsItf_,
	}, pGamma: ^i16) -> u32,
	GetSupportedGammaSettings: proc "c" (self: ^struct {
		using itf: ^XAImageControlsItf_,
	}, pMinValue: ^i16, pMaxValue: ^i16, pNumSettings: ^u32, ppSettings: ^^i16) -> u32,
}

XAImageDecoderCapabilitiesItf :: ^struct {
	using itf: ^XAImageDecoderCapabilitiesItf_,
}

XAImageDecoderCapabilitiesItf_ :: struct {
	GetImageDecoderCapabilities: proc "c" (self: ^struct {
		using itf: ^XAImageDecoderCapabilitiesItf_,
	}, pDecoderId: ^u32, pDescriptor: ^XAImageCodecDescriptor) -> u32,
	QueryColorFormats:           proc "c" (self: ^struct {
		using itf: ^XAImageDecoderCapabilitiesItf_,
	}, pIndex: ^u32, pColorFormat: ^u32) -> u32,
}

XAImageEffectsItf :: ^struct {
	using itf: ^XAImageEffectsItf_,
}

XAImageEffectsItf_ :: struct {
	QuerySupportedImageEffects: proc "c" (self: ^struct {
		using itf: ^XAImageEffectsItf_,
	}, index: u32, pImageEffectId: ^u32) -> u32,
	EnableImageEffect:          proc "c" (self: ^struct {
		using itf: ^XAImageEffectsItf_,
	}, imageEffectID: u32) -> u32,
	DisableImageEffect:         proc "c" (self: ^struct {
		using itf: ^XAImageEffectsItf_,
	}, imageEffectID: u32) -> u32,
	IsImageEffectEnabled:       proc "c" (self: ^struct {
		using itf: ^XAImageEffectsItf_,
	}, imageEffectID: u32, pEnabled: ^u32) -> u32,
}

XAImageEncoderCapabilitiesItf :: ^struct {
	using itf: ^XAImageEncoderCapabilitiesItf_,
}

XAImageEncoderCapabilitiesItf_ :: struct {
	GetImageEncoderCapabilities: proc "c" (self: ^struct {
		using itf: ^XAImageEncoderCapabilitiesItf_,
	}, pEncoderId: ^u32, pDescriptor: ^XAImageCodecDescriptor) -> u32,
	QueryColorFormats:           proc "c" (self: ^struct {
		using itf: ^XAImageEncoderCapabilitiesItf_,
	}, pIndex: ^u32, pColorFormat: ^u32) -> u32,
}

XAImageEncoderItf :: ^struct {
	using itf: ^XAImageEncoderItf_,
}

XAImageEncoderItf_ :: struct {
	SetImageSettings: proc "c" (self: ^struct {
		using itf: ^XAImageEncoderItf_,
	}, pSettings: ^XAImageSettings) -> u32,
	GetImageSettings: proc "c" (self: ^struct {
		using itf: ^XAImageEncoderItf_,
	}, pSettings: ^XAImageSettings) -> u32,
	GetSizeEstimate:  proc "c" (self: ^struct {
		using itf: ^XAImageEncoderItf_,
	}, pSize: ^u32) -> u32,
}

XAImageSettings :: struct {
	encoderId:        u32,
	width:            u32,
	height:           u32,
	compressionLevel: i16,
	colorFormat:      u32,
}

XAImageStreamInformation :: struct {
	codecId:              u32,
	width:                u32,
	height:               u32,
	presentationDuration: u32,
}

XAInterfaceID :: ^XAInterfaceID_

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

XALEDArrayItf :: ^struct {
	using itf: ^XALEDArrayItf_,
}

XALEDArrayItf_ :: struct {
	ActivateLEDArray:    proc "c" (self: ^struct {
		using itf: ^XALEDArrayItf_,
	}, lightMask: u32) -> u32,
	IsLEDArrayActivated: proc "c" (self: ^struct {
		using itf: ^XALEDArrayItf_,
	}, pLightMask: ^u32) -> u32,
	SetColor:            proc "c" (self: ^struct {
		using itf: ^XALEDArrayItf_,
	}, index: u8, pColor: ^XAHSL) -> u32,
	GetColor:            proc "c" (self: ^struct {
		using itf: ^XALEDArrayItf_,
	}, index: u8, pColor: ^XAHSL) -> u32,
}

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

XAMIDIStreamInformation :: struct {
	channels:    u32,
	tracks:      u32,
	bankType:    u32,
	langCountry: [16]u8,
	duration:    u32,
}

XAMediaContainerInformation :: struct {
	containerType: u32,
	mediaDuration: u32,
	numStreams:    u32,
}

XAMetadataExtractionItf :: ^struct {
	using itf: ^XAMetadataExtractionItf_,
}

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

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

XAMetadataInsertionItf :: ^struct {
	using itf: ^XAMetadataInsertionItf_,
}

XAMetadataInsertionItf_ :: struct {
	CreateChildNode:       proc "c" (self: ^struct {
		using itf: ^XAMetadataInsertionItf_,
	}, parentNodeID: i32, type: u32, mimeType: ^u8, pChildNodeID: ^i32) -> u32,
	GetSupportedKeysCount: proc "c" (self: ^struct {
		using itf: ^XAMetadataInsertionItf_,
	}, nodeID: i32, pFreeKeys: ^u32, pKeyCount: ^u32, pEncodingCount: ^u32) -> u32,
	GetKeySize:            proc "c" (self: ^struct {
		using itf: ^XAMetadataInsertionItf_,
	}, nodeID: i32, keyIndex: u32, pKeySize: ^u32) -> u32,
	GetKey:                proc "c" (self: ^struct {
		using itf: ^XAMetadataInsertionItf_,
	}, nodeID: i32, keyIndex: u32, keySize: u32, pKey: ^XAMetadataInfo) -> u32,
	GetFreeKeysEncoding:   proc "c" (self: ^struct {
		using itf: ^XAMetadataInsertionItf_,
	}, nodeID: i32, encodingIndex: u32, pEncoding: ^u32) -> u32,
	InsertMetadataItem:    proc "c" (self: ^struct {
		using itf: ^XAMetadataInsertionItf_,
	}, nodeID: i32, pKey: ^XAMetadataInfo, pValue: ^XAMetadataInfo, overwrite: u32) -> u32,
	RegisterCallback:      proc "c" (self: ^struct {
		using itf: ^XAMetadataInsertionItf_,
	}, callback: xaMetadataInsertionCallback, pContext: rawptr) -> u32,
}

XAMetadataTraversalItf :: ^struct {
	using itf: ^XAMetadataTraversalItf_,
}

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

XANativeHandle :: rawptr

XAObjectItf :: ^struct {
	using itf: ^XAObjectItf_,
}

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

XAOutputMixItf :: ^struct {
	using itf: ^XAOutputMixItf_,
}

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

XAPlayItf :: ^struct {
	using itf: ^XAPlayItf_,
}

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

XAPlaybackRateItf :: ^struct {
	using itf: ^XAPlaybackRateItf_,
}

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

XAPrefetchStatusItf :: ^struct {
	using itf: ^XAPrefetchStatusItf_,
}

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

XARDSItf :: ^struct {
	using itf: ^XARDSItf_,
}

XARDSItf_ :: struct {
	QueryRDSSignal:                  proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, isSignal: ^u32) -> u32,
	GetProgrammeServiceName:         proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, ps: ^u8) -> u32,
	GetRadioText:                    proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, rt: ^u8) -> u32,
	GetRadioTextPlus:                proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, contentType: u8, informationElement: ^u8, descriptor: ^u8, descriptorContentType: ^u8) -> u32,
	GetProgrammeType:                proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, pty: ^u32) -> u32,
	GetProgrammeTypeString:          proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, isLengthMax16: u32, pty: ^u8) -> u32,
	GetProgrammeIdentificationCode:  proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, pi: ^i16) -> u32,
	GetClockTime:                    proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, dateAndTime: ^u64) -> u32,
	GetTrafficAnnouncement:          proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, ta: ^u32) -> u32,
	GetTrafficProgramme:             proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, tp: ^u32) -> u32,
	SeekByProgrammeType:             proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, pty: u32, upwards: u32) -> u32,
	SeekTrafficAnnouncement:         proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, upwards: u32) -> u32,
	SeekTrafficProgramme:            proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, upwards: u32) -> u32,
	SetAutomaticSwitching:           proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, automatic: u32) -> u32,
	GetAutomaticSwitching:           proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, automatic: ^u32) -> u32,
	SetAutomaticTrafficAnnouncement: proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, automatic: u32) -> u32,
	GetAutomaticTrafficAnnouncement: proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, automatic: ^u32) -> u32,
	GetODAGroup:                     proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, AID: u16, callback: xaGetODAGroupCallback, pContext: rawptr) -> u32,
	SubscribeODAGroup:               proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, group: i16, useErrorCorrection: u32) -> u32,
	UnsubscribeODAGroup:             proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, group: i16) -> u32,
	ListODAGroupSubscriptions:       proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, pGroups: ^i16, pLength: ^u32) -> u32,
	RegisterRDSCallback:             proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, callback: xaRDSCallback, pContext: rawptr) -> u32,
	RegisterODADataCallback:         proc "c" (self: ^struct {
		using itf: ^XARDSItf_,
	}, callback: xaNewODADataCallback, pContext: rawptr) -> u32,
}

XARadioItf :: ^struct {
	using itf: ^XARadioItf_,
}

XARadioItf_ :: struct {
	SetFreqRange:           proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, range: u8) -> u32,
	GetFreqRange:           proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, pRange: ^u8) -> u32,
	IsFreqRangeSupported:   proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, range: u8, pSupported: ^u32) -> u32,
	GetFreqRangeProperties: proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, range: u8, pMinFreq: ^u32, pMaxFreq: ^u32, pFreqInterval: ^u32) -> u32,
	SetFrequency:           proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, freq: u32) -> u32,
	CancelSetFrequency:     proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}) -> u32,
	GetFrequency:           proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, pFreq: ^u32) -> u32,
	SetSquelch:             proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, squelch: u32) -> u32,
	GetSquelch:             proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, pSquelch: ^u32) -> u32,
	SetStereoMode:          proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, mode: u32) -> u32,
	GetStereoMode:          proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, pMode: ^u32) -> u32,
	GetSignalStrength:      proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, pStrength: ^u32) -> u32,
	Seek:                   proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, upwards: u32) -> u32,
	StopSeeking:            proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}) -> u32,
	GetNumberOfPresets:     proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, pNumPresets: ^u32) -> u32,
	SetPreset:              proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, preset: u32, freq: u32, range: u8, mode: u32, pName: ^u8) -> u32,
	GetPreset:              proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, preset: u32, pFreq: ^u32, pRange: ^u8, pMode: ^u32, pName: ^u8, pNameLength: ^u16) -> u32,
	RegisterRadioCallback:  proc "c" (self: ^struct {
		using itf: ^XARadioItf_,
	}, callback: xaRadioCallback, pContext: rawptr) -> u32,
}

XARecordItf :: ^struct {
	using itf: ^XARecordItf_,
}

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

XARectangle :: struct {
	left:   u32,
	top:    u32,
	width:  u32,
	height: u32,
}

XASeekItf :: ^struct {
	using itf: ^XASeekItf_,
}

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

XASnapshotItf :: ^struct {
	using itf: ^XASnapshotItf_,
}

XASnapshotItf_ :: struct {
	InitiateSnapshot:   proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}, numberOfPictures: u32, fps: u32, freezeViewFinder: u32, sink: XADataSink, initiatedCallback: xaSnapshotInitiatedCallback, takenCallback: xaSnapshotTakenCallback, pContext: rawptr) -> u32,
	TakeSnapshot:       proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}) -> u32,
	CancelSnapshot:     proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}) -> u32,
	ReleaseBuffers:     proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}, image: ^XADataSink) -> u32,
	GetMaxPicsPerBurst: proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}, maxNumberOfPictures: ^u32) -> u32,
	GetBurstFPSRange:   proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}, minFPS: ^u32, maxFPS: ^u32) -> u32,
	SetShutterFeedback: proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}, enabled: u32) -> u32,
	GetShutterFeedback: proc "c" (self: ^struct {
		using itf: ^XASnapshotItf_,
	}, enabled: ^u32) -> u32,
}

XAStreamInformationItf :: ^struct {
	using itf: ^XAStreamInformationItf_,
}

XAStreamInformationItf_ :: struct {
	QueryMediaContainerInformation: proc "c" (self: ^struct {
		using itf: ^XAStreamInformationItf_,
	}, info: ^XAMediaContainerInformation) -> u32,
	QueryStreamType:                proc "c" (self: ^struct {
		using itf: ^XAStreamInformationItf_,
	}, streamIndex: u32, domain: ^u32) -> u32,
	QueryStreamInformation:         proc "c" (self: ^struct {
		using itf: ^XAStreamInformationItf_,
	}, streamIndex: u32, info: rawptr) -> u32,
	QueryStreamName:                proc "c" (self: ^struct {
		using itf: ^XAStreamInformationItf_,
	}, streamIndex: u32, pNameSize: ^u16, pName: ^u8) -> u32,
	RegisterStreamChangeCallback:   proc "c" (self: ^struct {
		using itf: ^XAStreamInformationItf_,
	}, callback: xaStreamEventChangeCallback, pContext: rawptr) -> u32,
	QueryActiveStreams:             proc "c" (self: ^struct {
		using itf: ^XAStreamInformationItf_,
	}, numStreams: ^u32, activeStreams: ^u32) -> u32,
	SetActiveStream:                proc "c" (self: ^struct {
		using itf: ^XAStreamInformationItf_,
	}, streamNum: u32, active: u32, commitNow: u32) -> u32,
}

XAThreadSyncItf :: ^struct {
	using itf: ^XAThreadSyncItf_,
}

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

XATimedTextStreamInformation :: struct {
	layer:       u16,
	width:       u32,
	height:      u32,
	tx:          u16,
	ty:          u16,
	bitrate:     u32,
	langCountry: [16]u8,
	duration:    u32,
}

XAVendorStreamInformation :: struct {
	VendorStreamInfo: rawptr,
}

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

XAVibraItf :: ^struct {
	using itf: ^XAVibraItf_,
}

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

XAVideoCodecDescriptor :: struct {
	codecId:              u32,
	maxWidth:             u32,
	maxHeight:            u32,
	maxFrameRate:         u32,
	maxBitRate:           u32,
	rateControlSupported: u32,
	profileSetting:       u32,
	levelSetting:         u32,
}

XAVideoDecoderCapabilitiesItf :: ^struct {
	using itf: ^XAVideoDecoderCapabilitiesItf_,
}

XAVideoDecoderCapabilitiesItf_ :: struct {
	GetVideoDecoders:            proc "c" (self: ^struct {
		using itf: ^XAVideoDecoderCapabilitiesItf_,
	}, pNumDecoders: ^u32, pDecoderIds: ^u32) -> u32,
	GetVideoDecoderCapabilities: proc "c" (self: ^struct {
		using itf: ^XAVideoDecoderCapabilitiesItf_,
	}, decoderId: u32, pIndex: ^u32, pDescriptor: ^XAVideoCodecDescriptor) -> u32,
}

XAVideoEncoderCapabilitiesItf :: ^struct {
	using itf: ^XAVideoEncoderCapabilitiesItf_,
}

XAVideoEncoderCapabilitiesItf_ :: struct {
	GetVideoEncoders:            proc "c" (self: ^struct {
		using itf: ^XAVideoEncoderCapabilitiesItf_,
	}, pNumEncoders: ^u32, pEncoderIds: ^u32) -> u32,
	GetVideoEncoderCapabilities: proc "c" (self: ^struct {
		using itf: ^XAVideoEncoderCapabilitiesItf_,
	}, encoderId: u32, pIndex: ^u32, pDescriptor: ^XAVideoCodecDescriptor) -> u32,
}

XAVideoEncoderItf :: ^struct {
	using itf: ^XAVideoEncoderItf_,
}

XAVideoEncoderItf_ :: struct {
	SetVideoSettings: proc "c" (self: ^struct {
		using itf: ^XAVideoEncoderItf_,
	}, pSettings: ^XAVideoSettings) -> u32,
	GetVideoSettings: proc "c" (self: ^struct {
		using itf: ^XAVideoEncoderItf_,
	}, pSettings: ^XAVideoSettings) -> u32,
}

XAVideoPostProcessingItf :: ^struct {
	using itf: ^XAVideoPostProcessingItf_,
}

XAVideoPostProcessingItf_ :: struct {
	SetRotation:                  proc "c" (self: ^struct {
		using itf: ^XAVideoPostProcessingItf_,
	}, rotation: i32) -> u32,
	IsArbitraryRotationSupported: proc "c" (self: ^struct {
		using itf: ^XAVideoPostProcessingItf_,
	}, pSupported: ^u32) -> u32,
	SetScaleOptions:              proc "c" (self: ^struct {
		using itf: ^XAVideoPostProcessingItf_,
	}, scaleOptions: u32, backgroundColor: u32, renderingHints: u32) -> u32,
	SetSourceRectangle:           proc "c" (self: ^struct {
		using itf: ^XAVideoPostProcessingItf_,
	}, pSrcRect: ^XARectangle) -> u32,
	SetDestinationRectangle:      proc "c" (self: ^struct {
		using itf: ^XAVideoPostProcessingItf_,
	}, pDestRect: ^XARectangle) -> u32,
	SetMirror:                    proc "c" (self: ^struct {
		using itf: ^XAVideoPostProcessingItf_,
	}, mirror: u32) -> u32,
	Commit:                       proc "c" (self: ^struct {
		using itf: ^XAVideoPostProcessingItf_,
	}) -> u32,
}

XAVideoSettings :: struct {
	encoderId:        u32,
	width:            u32,
	height:           u32,
	frameRate:        u32,
	bitRate:          u32,
	rateControl:      u32,
	profileSetting:   u32,
	levelSetting:     u32,
	keyFrameInterval: u32,
}

XAVideoStreamInformation :: struct {
	codecId:   u32,
	width:     u32,
	height:    u32,
	frameRate: u32,
	bitRate:   u32,
	duration:  u32,
}

XAVolumeItf :: ^struct {
	using itf: ^XAVolumeItf_,
}

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

XAboolean :: u32

XAchar :: u8

XAint16 :: i16

XAint32 :: i32

XAint8 :: i8

XAmicrosecond :: u32

XAmilliHertz :: u32

XAmillibel :: i16

XAmillidegree :: i32

XAmillimeter :: i32

XAmillisecond :: u32

XApermille :: i16

XAresult :: u32

XAtime :: u64

XAuint16 :: u16

XAuint32 :: u32

XAuint64 :: u64

XAuint8 :: u8

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

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

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

xaCameraCallback :: proc "c" (caller: ^struct {
	using itf: ^XACameraItf_,
}, pContext: rawptr, eventId: u32, eventData: u32)

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

xaDynamicInterfaceManagementCallback :: proc "c" (caller: ^struct {
	using itf: ^XADynamicInterfaceManagementItf_,
}, pContext: rawptr, event: u32, result: u32, iid: ^XAInterfaceID_)

xaGetODAGroupCallback :: proc "c" (caller: ^struct {
	using itf: ^XARadioItf_,
}, pContext: rawptr, success: u32, group: i16, message: u16)

xaMetadataInsertionCallback :: proc "c" (caller: ^struct {
	using itf: ^XAMetadataInsertionItf_,
}, pContext: rawptr, pKey: ^XAMetadataInfo, pValue: ^XAMetadataInfo, nodeID: i32, result: u32)

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

xaNewODADataCallback :: proc "c" (caller: ^struct {
	using itf: ^XARDSItf_,
}, pContext: rawptr, group: i16, data: u64)

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

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

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

xaRDSCallback :: proc "c" (caller: ^struct {
	using itf: ^XARDSItf_,
}, pContext: rawptr, event: u16, eventData: u8)

xaRadioCallback :: proc "c" (caller: ^struct {
	using itf: ^XARadioItf_,
}, pContext: rawptr, event: u32, eventIntData: u32, eventBooleanData: u32)

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

xaSnapshotInitiatedCallback :: proc "c" (caller: ^struct {
	using itf: ^XASnapshotItf_,
}, context_: rawptr)

xaSnapshotTakenCallback :: proc "c" (caller: ^struct {
	using itf: ^XASnapshotItf_,
}, context_: rawptr, numberOfPicsTaken: u32, image: ^XADataSink)

xaStreamEventChangeCallback :: proc "c" (caller: ^struct {
	using itf: ^XAStreamInformationItf_,
}, eventId: u32, streamIndex: u32, pEventData: rawptr, pContext: rawptr)

xa_int16_t :: i16

xa_int32_t :: i32

xa_int64_t :: i64

xa_int8_t :: i8

xa_uint16_t :: u16

xa_uint32_t :: u32

xa_uint64_t :: u64

xa_uint8_t :: u8

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"

XA_ANDROIDBUFFERQUEUEEVENT_NONE :: 0x0

XA_ANDROIDBUFFERQUEUEEVENT_PROCESSED :: 0x1

XA_ANDROID_FORMATCHANGE_ITEMDATA_VIDEO :: 0x1

XA_ANDROID_ITEMKEY_BUFFERQUEUEEVENT :: 0x3

XA_ANDROID_ITEMKEY_DISCONTINUITY :: 0x2

XA_ANDROID_ITEMKEY_EOS :: 0x1

XA_ANDROID_ITEMKEY_FORMAT_CHANGE :: 0x4

XA_ANDROID_ITEMKEY_NONE :: 0x0