api_wasapi_windows.go

// Copyright 2022 The Oto Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package oto

import (
	"fmt"
	"runtime"
	"syscall"
	"unsafe"

	"golang.org/x/sys/windows"
)

var (
	ole32 = windows.NewLazySystemDLL("ole32")
)

var (
	procCoCreateInstance = ole32.NewProc("CoCreateInstance")
	procCoInitializeEx   = ole32.NewProc("CoInitializeEx")
	procCoUninitialize   = ole32.NewProc("CoUninitialize")
)

type _REFERENCE_TIME int64

var (
	uuidIAudioClient2       = windows.GUID{0x726778cd, 0xf60a, 0x4eda, [...]byte{0x82, 0xde, 0xe4, 0x76, 0x10, 0xcd, 0x78, 0xaa}}
	uuidIAudioRenderClient  = windows.GUID{0xf294acfc, 0x3146, 0x4483, [...]byte{0xa7, 0xbf, 0xad, 0xdc, 0xa7, 0xc2, 0x60, 0xe2}}
	uuidIMMDeviceEnumerator = windows.GUID{0xa95664d2, 0x9614, 0x4f35, [...]byte{0xa7, 0x46, 0xde, 0x8d, 0xb6, 0x36, 0x17, 0xe6}}
	uuidMMDeviceEnumerator  = windows.GUID{0xbcde0395, 0xe52f, 0x467c, [...]byte{0x8e, 0x3d, 0xc4, 0x57, 0x92, 0x91, 0x69, 0x2e}}
)

const (
	_AUDCLNT_STREAMFLAGS_EVENTCALLBACK = 0x00040000
	_AUDCLNT_STREAMFLAGS_NOPERSIST     = 0x00080000
	_COINIT_APARTMENTTHREADED          = 0x2
	_COINIT_MULTITHREADED              = 0
	_REFTIMES_PER_SEC                  = 10000000
	_SPEAKER_FRONT_CENTER              = 0x4
	_SPEAKER_FRONT_LEFT                = 0x1
	_SPEAKER_FRONT_RIGHT               = 0x2
	_WAVE_FORMAT_EXTENSIBLE            = 0xfffe
)

var (
	_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = windows.GUID{0x00000003, 0x0000, 0x0010, [...]byte{0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}}
	_KSDATAFORMAT_SUBTYPE_PCM        = windows.GUID{0x00000001, 0x0000, 0x0010, [...]byte{0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}}
)

type _AUDCLNT_ERR uint32

const (
	_AUDCLNT_E_DEVICE_INVALIDATED    _AUDCLNT_ERR = 0x88890004
	_AUDCLNT_E_RESOURCES_INVALIDATED _AUDCLNT_ERR = 0x88890026
)

func isAudclntErr(hresult uint32) bool {
	return hresult&0xffff0000 == (1<<31)|(windows.FACILITY_AUDCLNT<<16)
}

func (e _AUDCLNT_ERR) Error() string {
	switch e {
	case _AUDCLNT_E_DEVICE_INVALIDATED:
		return "AUDCLNT_E_DEVICE_INVALIDATED"
	case _AUDCLNT_E_RESOURCES_INVALIDATED:
		return "AUDCLNT_E_RESOURCES_INVALIDATED"
	default:
		return fmt.Sprintf("AUDCLNT_ERR(%d)", e)
	}
}

type _AUDCLNT_SHAREMODE int32

const (
	_AUDCLNT_SHAREMODE_SHARED    _AUDCLNT_SHAREMODE = 0
	_AUDCLNT_SHAREMODE_EXCLUSIVE _AUDCLNT_SHAREMODE = 1
)

type _AUDCLNT_STREAMOPTIONS int32

const (
	_AUDCLNT_STREAMOPTIONS_NONE         _AUDCLNT_STREAMOPTIONS = 0x0
	_AUDCLNT_STREAMOPTIONS_RAW          _AUDCLNT_STREAMOPTIONS = 0x1
	_AUDCLNT_STREAMOPTIONS_MATCH_FORMAT _AUDCLNT_STREAMOPTIONS = 0x2
	_AUDCLNT_STREAMOPTIONS_AMBISONICS   _AUDCLNT_STREAMOPTIONS = 0x4
)

type _AUDIO_STREAM_CATEGORY int32

const (
	_AudioCategory_Other                  _AUDIO_STREAM_CATEGORY = 0
	_AudioCategory_ForegroundOnlyMedia    _AUDIO_STREAM_CATEGORY = 1
	_AudioCategory_BackgroundCapableMedia _AUDIO_STREAM_CATEGORY = 2
	_AudioCategory_Communications         _AUDIO_STREAM_CATEGORY = 3
	_AudioCategory_Alerts                 _AUDIO_STREAM_CATEGORY = 4
	_AudioCategory_SoundEffects           _AUDIO_STREAM_CATEGORY = 5
	_AudioCategory_GameEffects            _AUDIO_STREAM_CATEGORY = 6
	_AudioCategory_GameMedia              _AUDIO_STREAM_CATEGORY = 7
	_AudioCategory_GameChat               _AUDIO_STREAM_CATEGORY = 8
	_AudioCategory_Speech                 _AUDIO_STREAM_CATEGORY = 9
	_AudioCategory_Movie                  _AUDIO_STREAM_CATEGORY = 10
	_AudioCategory_Media                  _AUDIO_STREAM_CATEGORY = 11
)

type _CLSCTX int32

const (
	_CLSCTX_INPROC_SERVER  _CLSCTX = 0x00000001
	_CLSCTX_INPROC_HANDLER _CLSCTX = 0x00000002
	_CLSCTX_LOCAL_SERVER   _CLSCTX = 0x00000004
	_CLSCTX_REMOTE_SERVER  _CLSCTX = 0x00000010
	_CLSCTX_ALL                    = _CLSCTX_INPROC_SERVER | _CLSCTX_INPROC_HANDLER | _CLSCTX_LOCAL_SERVER | _CLSCTX_REMOTE_SERVER
)

type _EDataFlow int32

const (
	eRender _EDataFlow = 0
)

type _ERole int32

const (
	eConsole _ERole = 0
)

type _WIN32_ERR uint32

const (
	_E_NOTFOUND _WIN32_ERR = 0x80070490
)

func isWin32Err(hresult uint32) bool {
	return hresult&0xffff0000 == (1<<31)|(windows.FACILITY_WIN32<<16)
}

func (e _WIN32_ERR) Error() string {
	switch e {
	case _E_NOTFOUND:
		return "E_NOTFOUND"
	default:
		return fmt.Sprintf("HRESULT(%d)", e)
	}
}

type _AudioClientProperties struct {
	cbSize     uint32
	bIsOffload int32
	eCategory  _AUDIO_STREAM_CATEGORY
	Options    _AUDCLNT_STREAMOPTIONS
}

type _PROPVARIANT struct {
	// TODO: Implmeent this
}

type _WAVEFORMATEXTENSIBLE struct {
	wFormatTag      uint16
	nChannels       uint16
	nSamplesPerSec  uint32
	nAvgBytesPerSec uint32
	nBlockAlign     uint16
	wBitsPerSample  uint16
	cbSize          uint16
	Samples         uint16 // union
	dwChannelMask   uint32
	SubFormat       windows.GUID
}

func _CoCreateInstance(rclsid *windows.GUID, pUnkOuter unsafe.Pointer, dwClsContext uint32, riid *windows.GUID) (unsafe.Pointer, error) {
	var v unsafe.Pointer
	r, _, _ := procCoCreateInstance.Call(uintptr(unsafe.Pointer(rclsid)), uintptr(pUnkOuter), uintptr(dwClsContext), uintptr(unsafe.Pointer(riid)), uintptr(unsafe.Pointer(&v)))
	runtime.KeepAlive(rclsid)
	runtime.KeepAlive(riid)
	if uint32(r) != uint32(windows.S_OK) {
		return nil, fmt.Errorf("oto: CoCreateInstance failed: HRESULT(%d)", uint32(r))
	}
	return v, nil
}

func _CoInitializeEx(pvReserved unsafe.Pointer, dwCoInit uint32) error {
	r, _, _ := procCoInitializeEx.Call(uintptr(pvReserved), uintptr(dwCoInit))
	// S_FALSE is returned when CoInitializeEx is nested. This is a successful case.
	if uint32(r) != uint32(windows.S_OK) && uint32(r) != uint32(windows.S_FALSE) {
		return fmt.Errorf("oto: CoInitializeEx failed: HRESULT(%d)", uint32(r))
	}
	return nil
}

func _CoUninitialize() {
	procCoUninitialize.Call()
}

type _IAudioClient2 struct {
	vtbl *_IAudioClient2_Vtbl
}

type _IAudioClient2_Vtbl struct {
	QueryInterface uintptr
	AddRef         uintptr
	Release        uintptr

	Initialize          uintptr
	GetBufferSize       uintptr
	GetStreamLatency    uintptr
	GetCurrentPadding   uintptr
	IsFormatSupported   uintptr
	GetMixFormat        uintptr
	GetDevicePeriod     uintptr
	Start               uintptr
	Stop                uintptr
	Reset               uintptr
	SetEventHandle      uintptr
	GetService          uintptr
	IsOffloadCapable    uintptr
	SetClientProperties uintptr
	GetBufferSizeLimits uintptr
}

func (i *_IAudioClient2) GetBufferSize() (uint32, error) {
	var numBufferFrames uint32
	r, _, _ := syscall.Syscall(i.vtbl.GetBufferSize, 2, uintptr(unsafe.Pointer(i)), uintptr(unsafe.Pointer(&numBufferFrames)), 0)
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return 0, fmt.Errorf("oto: IAudioClient2::GetBufferSize failed: %w", _AUDCLNT_ERR(r))
		}
		return 0, fmt.Errorf("oto: IAudioClient2::GetBufferSize failed: HRESULT(%d)", uint32(r))
	}
	return numBufferFrames, nil
}

func (i *_IAudioClient2) GetCurrentPadding() (uint32, error) {
	var numPaddingFrames uint32
	r, _, _ := syscall.Syscall(i.vtbl.GetCurrentPadding, 2, uintptr(unsafe.Pointer(i)), uintptr(unsafe.Pointer(&numPaddingFrames)), 0)
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return 0, fmt.Errorf("oto: IAudioClient2::GetCurrentPadding failed: %w", _AUDCLNT_ERR(r))
		}
		return 0, fmt.Errorf("oto: IAudioClient2::GetCurrentPadding failed: HRESULT(%d)", uint32(r))
	}
	return numPaddingFrames, nil
}

func (i *_IAudioClient2) GetDevicePeriod() (_REFERENCE_TIME, _REFERENCE_TIME, error) {
	var defaultDevicePeriod _REFERENCE_TIME
	var minimumDevicePeriod _REFERENCE_TIME
	r, _, _ := syscall.Syscall(i.vtbl.GetDevicePeriod, 3, uintptr(unsafe.Pointer(i)),
		uintptr(unsafe.Pointer(&defaultDevicePeriod)), uintptr(unsafe.Pointer(&minimumDevicePeriod)))
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return 0, 0, fmt.Errorf("oto: IAudioClient2::GetDevicePeriod failed: %w", _AUDCLNT_ERR(r))
		}
		return 0, 0, fmt.Errorf("oto: IAudioClient2::GetDevicePeriod failed: HRESULT(%d)", uint32(r))
	}
	return defaultDevicePeriod, minimumDevicePeriod, nil
}

func (i *_IAudioClient2) GetService(riid *windows.GUID) (unsafe.Pointer, error) {
	var v unsafe.Pointer
	r, _, _ := syscall.Syscall(i.vtbl.GetService, 3, uintptr(unsafe.Pointer(i)), uintptr(unsafe.Pointer(riid)), uintptr(unsafe.Pointer(&v)))
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return nil, fmt.Errorf("oto: IAudioClient2::GetService failed: %w", _AUDCLNT_ERR(r))
		}
		return nil, fmt.Errorf("oto: IAudioClient2::GetService failed: HRESULT(%d)", uint32(r))
	}
	return v, nil
}

func (i *_IAudioClient2) Initialize(shareMode _AUDCLNT_SHAREMODE, streamFlags uint32, hnsBufferDuration _REFERENCE_TIME, hnsPeriodicity _REFERENCE_TIME, pFormat *_WAVEFORMATEXTENSIBLE, audioSessionGuid *windows.GUID) error {
	var r uintptr
	if unsafe.Sizeof(uintptr(0)) == 8 {
		// 64bits
		r, _, _ = syscall.Syscall9(i.vtbl.Initialize, 7, uintptr(unsafe.Pointer(i)),
			uintptr(shareMode), uintptr(streamFlags), uintptr(hnsBufferDuration),
			uintptr(hnsPeriodicity), uintptr(unsafe.Pointer(pFormat)), uintptr(unsafe.Pointer(audioSessionGuid)),
			0, 0)
	} else {
		// 32bits
		r, _, _ = syscall.Syscall9(i.vtbl.Initialize, 9, uintptr(unsafe.Pointer(i)),
			uintptr(shareMode), uintptr(streamFlags), uintptr(hnsBufferDuration),
			uintptr(hnsBufferDuration>>32), uintptr(hnsPeriodicity), uintptr(hnsPeriodicity>>32),
			uintptr(unsafe.Pointer(pFormat)), uintptr(unsafe.Pointer(audioSessionGuid)))
	}
	runtime.KeepAlive(pFormat)
	runtime.KeepAlive(audioSessionGuid)
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return fmt.Errorf("oto: IAudioClient2::Initialize failed: %w", _AUDCLNT_ERR(r))
		}
		return fmt.Errorf("oto: IAudioClient2::Initialize failed: HRESULT(%d)", uint32(r))
	}
	return nil
}

func (i *_IAudioClient2) IsFormatSupported(shareMode _AUDCLNT_SHAREMODE, pFormat *_WAVEFORMATEXTENSIBLE) (*_WAVEFORMATEXTENSIBLE, error) {
	var closestMatch *_WAVEFORMATEXTENSIBLE
	r, _, _ := syscall.Syscall6(i.vtbl.IsFormatSupported, 4, uintptr(unsafe.Pointer(i)),
		uintptr(shareMode), uintptr(unsafe.Pointer(pFormat)), uintptr(unsafe.Pointer(&closestMatch)),
		0, 0)
	if uint32(r) != uint32(windows.S_OK) {
		if uint32(r) == uint32(windows.S_FALSE) {
			return closestMatch, nil
		}
		if isAudclntErr(uint32(r)) {
			return nil, fmt.Errorf("oto: IAudioClient2::IsFormatSupported failed: %w", _AUDCLNT_ERR(r))
		}
		return nil, fmt.Errorf("oto: IAudioClient2::IsFormatSupported failed: HRESULT(%d)", uint32(r))
	}
	return nil, nil
}

func (i *_IAudioClient2) Release() uint32 {
	r, _, _ := syscall.Syscall(i.vtbl.Release, 1, uintptr(unsafe.Pointer(i)), 0, 0)
	return uint32(r)
}

func (i *_IAudioClient2) SetClientProperties(pProperties *_AudioClientProperties) error {
	r, _, _ := syscall.Syscall(i.vtbl.SetClientProperties, 2, uintptr(unsafe.Pointer(i)), uintptr(unsafe.Pointer(pProperties)), 0)
	runtime.KeepAlive(pProperties)
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return fmt.Errorf("oto: IAudioClient2::SetClientProperties failed: %w", _AUDCLNT_ERR(r))
		}
		return fmt.Errorf("oto: IAudioClient2::SetClientProperties failed: HRESULT(%d)", uint32(r))
	}
	return nil
}

func (i *_IAudioClient2) SetEventHandle(eventHandle windows.Handle) error {
	r, _, _ := syscall.Syscall(i.vtbl.SetEventHandle, 2, uintptr(unsafe.Pointer(i)), uintptr(eventHandle), 0)
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return fmt.Errorf("oto: IAudioClient2::SetEventHandle failed: %w", _AUDCLNT_ERR(r))
		}
		return fmt.Errorf("oto: IAudioClient2::SetEventHandle failed: HRESULT(%d)", uint32(r))
	}
	return nil
}

func (i *_IAudioClient2) Start() error {
	r, _, _ := syscall.Syscall(i.vtbl.Start, 1, uintptr(unsafe.Pointer(i)), 0, 0)
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return fmt.Errorf("oto: IAudioClient2::Start failed: %w", _AUDCLNT_ERR(r))
		}
		return fmt.Errorf("oto: IAudioClient2::Start failed: HRESULT(%d)", uint32(r))
	}
	return nil
}

func (i *_IAudioClient2) Stop() error {
	r, _, _ := syscall.Syscall(i.vtbl.Stop, 1, uintptr(unsafe.Pointer(i)), 0, 0)
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return fmt.Errorf("oto: IAudioClient2::Stop failed: %w", _AUDCLNT_ERR(r))
		}
		return fmt.Errorf("oto: IAudioClient2::Stop failed: HRESULT(%d)", uint32(r))
	}
	return nil
}

type _IAudioRenderClient struct {
	vtbl *_IAudioRenderClient_Vtbl
}

type _IAudioRenderClient_Vtbl struct {
	QueryInterface uintptr
	AddRef         uintptr
	Release        uintptr

	GetBuffer     uintptr
	ReleaseBuffer uintptr
}

func (i *_IAudioRenderClient) GetBuffer(numFramesRequested uint32) (*byte, error) {
	var data *byte
	r, _, _ := syscall.Syscall(i.vtbl.GetBuffer, 3, uintptr(unsafe.Pointer(i)), uintptr(numFramesRequested), uintptr(unsafe.Pointer(&data)))
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return nil, fmt.Errorf("oto: IAudioRenderClient::GetBuffer failed: %w", _AUDCLNT_ERR(r))
		}
		return nil, fmt.Errorf("oto: IAudioRenderClient::GetBuffer failed: HRESULT(%d)", uint32(r))
	}
	return data, nil
}

func (i *_IAudioRenderClient) Release() uint32 {
	r, _, _ := syscall.Syscall(i.vtbl.Release, 1, uintptr(unsafe.Pointer(i)), 0, 0)
	return uint32(r)
}

func (i *_IAudioRenderClient) ReleaseBuffer(numFramesWritten uint32, dwFlags uint32) error {
	r, _, _ := syscall.Syscall(i.vtbl.ReleaseBuffer, 3, uintptr(unsafe.Pointer(i)), uintptr(numFramesWritten), uintptr(dwFlags))
	if uint32(r) != uint32(windows.S_OK) {
		if isAudclntErr(uint32(r)) {
			return fmt.Errorf("oto: IAudioRenderClient::ReleaseBuffer failed: %w", _AUDCLNT_ERR(r))
		}
		return fmt.Errorf("oto: IAudioRenderClient::ReleaseBuffer failed: HRESULT(%d)", uint32(r))
	}
	return nil
}

type _IMMDevice struct {
	vtbl *_IMMDevice_Vtbl
}

type _IMMDevice_Vtbl struct {
	QueryInterface uintptr
	AddRef         uintptr
	Release        uintptr

	Activate          uintptr
	OpenPropertyStore uintptr
	GetId             uintptr
	GetState          uintptr
}

func (i *_IMMDevice) Activate(iid *windows.GUID, dwClsCtx uint32, pActivationParams *_PROPVARIANT) (unsafe.Pointer, error) {
	var v unsafe.Pointer
	r, _, _ := syscall.Syscall6(i.vtbl.Activate, 5, uintptr(unsafe.Pointer(i)),
		uintptr(unsafe.Pointer(iid)), uintptr(dwClsCtx), uintptr(unsafe.Pointer(pActivationParams)), uintptr(unsafe.Pointer(&v)), 0)
	runtime.KeepAlive(iid)
	runtime.KeepAlive(pActivationParams)
	if uint32(r) != uint32(windows.S_OK) {
		return nil, fmt.Errorf("oto: IMMDevice::Activate failed: HRESULT(%d)", uint32(r))
	}
	return v, nil
}

func (i *_IMMDevice) GetId() (string, error) {
	var strId *uint16
	r, _, _ := syscall.Syscall(i.vtbl.GetId, 2, uintptr(unsafe.Pointer(i)), uintptr(unsafe.Pointer(&strId)), 0)
	if uint32(r) != uint32(windows.S_OK) {
		return "", fmt.Errorf("oto: IMMDevice::GetId failed: HRESULT(%d)", uint32(r))
	}
	return windows.UTF16PtrToString(strId), nil
}

func (i *_IMMDevice) Release() {
	syscall.Syscall(i.vtbl.Release, 1, uintptr(unsafe.Pointer(i)), 0, 0)
}

type _IMMDeviceEnumerator struct {
	vtbl *_IMMDeviceEnumerator_Vtbl
}

type _IMMDeviceEnumerator_Vtbl struct {
	QueryInterface uintptr
	AddRef         uintptr
	Release        uintptr

	EnumAudioEndpoints                     uintptr
	GetDefaultAudioEndpoint                uintptr
	GetDevice                              uintptr
	RegisterEndpointNotificationCallback   uintptr
	UnregisterEndpointNotificationCallback uintptr
}

func (i *_IMMDeviceEnumerator) GetDefaultAudioEndPoint(dataFlow _EDataFlow, role _ERole) (*_IMMDevice, error) {
	var endPoint *_IMMDevice
	r, _, _ := syscall.Syscall6(i.vtbl.GetDefaultAudioEndpoint, 4, uintptr(unsafe.Pointer(i)),
		uintptr(dataFlow), uintptr(role), uintptr(unsafe.Pointer(&endPoint)), 0, 0)
	if uint32(r) != uint32(windows.S_OK) {
		if isWin32Err(uint32(r)) {
			return nil, fmt.Errorf("oto: IMMDeviceEnumerator::GetDefaultAudioEndPoint failed: %w", _E_NOTFOUND)
		}
		return nil, fmt.Errorf("oto: IMMDeviceEnumerator::GetDefaultAudioEndPoint failed: HRESULT(%d)", uint32(r))
	}
	return endPoint, nil
}

func (i *_IMMDeviceEnumerator) Release() {
	syscall.Syscall(i.vtbl.Release, 1, uintptr(unsafe.Pointer(i)), 0, 0)
}