diff --git a/configure b/configure index cc39d2025d2..164f3aa3b7c 100755 --- a/configure +++ b/configure @@ -1374,6 +1374,7 @@ enable_xapofx1_1 enable_xapofx1_3 enable_xapofx1_4 enable_xapofx1_5 +enable_xaudio2_3 enable_xaudio2_7 enable_xaudio2_8 enable_xinput1_1 @@ -17911,6 +17912,7 @@ wine_fn_config_dll xapofx1_1 enable_xapofx1_1 wine_fn_config_dll xapofx1_3 enable_xapofx1_3 wine_fn_config_dll xapofx1_4 enable_xapofx1_4 wine_fn_config_dll xapofx1_5 enable_xapofx1_5 +wine_fn_config_dll xaudio2_3 enable_xaudio2_3 clean wine_fn_config_dll xaudio2_7 enable_xaudio2_7 clean wine_fn_config_test dlls/xaudio2_7/tests xaudio2_7_test wine_fn_config_dll xaudio2_8 enable_xaudio2_8 diff --git a/configure.ac b/configure.ac index c37c491f7ec..97370beaa53 100644 --- a/configure.ac +++ b/configure.ac @@ -3460,6 +3460,7 @@ WINE_CONFIG_DLL(xapofx1_1) WINE_CONFIG_DLL(xapofx1_3) WINE_CONFIG_DLL(xapofx1_4) WINE_CONFIG_DLL(xapofx1_5) +WINE_CONFIG_DLL(xaudio2_3,,[clean]) WINE_CONFIG_DLL(xaudio2_7,,[clean]) WINE_CONFIG_TEST(dlls/xaudio2_7/tests) WINE_CONFIG_DLL(xaudio2_8) diff --git a/dlls/xaudio2_3/Makefile.in b/dlls/xaudio2_3/Makefile.in new file mode 100644 index 00000000000..0e9e2f31406 --- /dev/null +++ b/dlls/xaudio2_3/Makefile.in @@ -0,0 +1,7 @@ +MODULE = xaudio2_3.dll +IMPORTS = ole32 + +C_SRCS = \ + xaudio_dll.c + +IDL_SRCS = xaudio_classes.idl diff --git a/dlls/xaudio2_3/xaudio2_3.spec b/dlls/xaudio2_3/xaudio2_3.spec new file mode 100644 index 00000000000..cb263d4836b --- /dev/null +++ b/dlls/xaudio2_3/xaudio2_3.spec @@ -0,0 +1,4 @@ +@ stdcall -private DllCanUnloadNow() +@ stdcall -private DllGetClassObject(ptr ptr ptr) xaudio2_7.DllGetClassObject +@ stdcall -private DllRegisterServer() +@ stdcall -private DllUnregisterServer() diff --git a/dlls/xaudio2_3/xaudio_classes.idl b/dlls/xaudio2_3/xaudio_classes.idl new file mode 100644 index 00000000000..c95fac0ee6d --- /dev/null +++ b/dlls/xaudio2_3/xaudio_classes.idl @@ -0,0 +1,28 @@ +/* + * COM Classes for xaudio + * + * Copyright 2015 Andrew Eikum for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#pragma makedep register + +[ + helpstring("XAudio2.3 Class"), + threading(both), + uuid(4c5e637a-16c7-4de3-9c46-5ed22181962d) +] +coclass XAudio23 { interface IXAudio27; } diff --git a/dlls/xaudio2_3/xaudio_dll.c b/dlls/xaudio2_3/xaudio_dll.c new file mode 100644 index 00000000000..7c95c288ca0 --- /dev/null +++ b/dlls/xaudio2_3/xaudio_dll.c @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2015 Andrew Eikum for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include +#include "windef.h" +#include "winbase.h" +#include "objbase.h" +#include "rpcproxy.h" + +static HINSTANCE instance; + +BOOL WINAPI DllMain(HINSTANCE hinstance, DWORD reason, LPVOID reserved) +{ + switch (reason) + { + case DLL_PROCESS_ATTACH: + instance = hinstance; + DisableThreadLibraryCalls(hinstance); + break; + } + return TRUE; +} + +HRESULT WINAPI DllCanUnloadNow(void) +{ + return S_FALSE; +} + +HRESULT WINAPI DllRegisterServer(void) +{ + return __wine_register_resources(instance); +} + +HRESULT WINAPI DllUnregisterServer(void) +{ + return __wine_unregister_resources(instance); +} diff --git a/dlls/xaudio2_7/compat.c b/dlls/xaudio2_7/compat.c index 078c80189cf..114463a8740 100644 --- a/dlls/xaudio2_7/compat.c +++ b/dlls/xaudio2_7/compat.c @@ -580,3 +580,606 @@ const IXAudio27Vtbl XAudio27_Vtbl = { XA27_GetPerformanceData, XA27_SetDebugConfiguration }; + +XA2SourceImpl *impl_from_IXAudio23SourceVoice(IXAudio23SourceVoice *iface) +{ + return CONTAINING_RECORD(iface, XA2SourceImpl, IXAudio23SourceVoice_iface); +} + +static void WINAPI XA23SRC_GetVoiceDetails(IXAudio23SourceVoice *iface, + XAUDIO2_VOICE_DETAILS *pVoiceDetails) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetVoiceDetails(&This->IXAudio2SourceVoice_iface, pVoiceDetails); +} + +static HRESULT WINAPI XA23SRC_SetOutputVoices(IXAudio23SourceVoice *iface, + const XAUDIO23_VOICE_SENDS *pSendList) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + XAUDIO2_VOICE_SENDS sends; + HRESULT hr; + DWORD i; + + TRACE("%p, %p\n", This, pSendList); + + sends.SendCount = pSendList->OutputCount; + sends.pSends = HeapAlloc(GetProcessHeap(), 0, sends.SendCount * sizeof(*sends.pSends)); + for(i = 0; i < sends.SendCount; ++i){ + sends.pSends[i].Flags = 0; + sends.pSends[i].pOutputVoice = pSendList->pOutputVoices[i]; + } + + hr = IXAudio2SourceVoice_SetOutputVoices(&This->IXAudio2SourceVoice_iface, &sends); + + HeapFree(GetProcessHeap(), 0, sends.pSends); + + return hr; +} + +static HRESULT WINAPI XA23SRC_SetEffectChain(IXAudio23SourceVoice *iface, + const XAUDIO2_EFFECT_CHAIN *pEffectChain) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SetEffectChain(&This->IXAudio2SourceVoice_iface, pEffectChain); +} + +static HRESULT WINAPI XA23SRC_EnableEffect(IXAudio23SourceVoice *iface, + UINT32 EffectIndex, UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_EnableEffect(&This->IXAudio2SourceVoice_iface, + EffectIndex, OperationSet); +} + +static HRESULT WINAPI XA23SRC_DisableEffect(IXAudio23SourceVoice *iface, + UINT32 EffectIndex, UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_DisableEffect(&This->IXAudio2SourceVoice_iface, + EffectIndex, OperationSet); +} + +static void WINAPI XA23SRC_GetEffectState(IXAudio23SourceVoice *iface, + UINT32 EffectIndex, BOOL *pEnabled) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetEffectState(&This->IXAudio2SourceVoice_iface, + EffectIndex, pEnabled); +} + +static HRESULT WINAPI XA23SRC_SetEffectParameters(IXAudio23SourceVoice *iface, + UINT32 EffectIndex, const void *pParameters, UINT32 ParametersByteSize, + UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SetEffectParameters(&This->IXAudio2SourceVoice_iface, + EffectIndex, pParameters, ParametersByteSize, OperationSet); +} + +static HRESULT WINAPI XA23SRC_GetEffectParameters(IXAudio23SourceVoice *iface, + UINT32 EffectIndex, void *pParameters, UINT32 ParametersByteSize) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetEffectParameters(&This->IXAudio2SourceVoice_iface, + EffectIndex, pParameters, ParametersByteSize); +} + +static HRESULT WINAPI XA23SRC_SetFilterParameters(IXAudio23SourceVoice *iface, + const XAUDIO2_FILTER_PARAMETERS *pParameters, UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SetFilterParameters(&This->IXAudio2SourceVoice_iface, + pParameters, OperationSet); +} + +static void WINAPI XA23SRC_GetFilterParameters(IXAudio23SourceVoice *iface, + XAUDIO2_FILTER_PARAMETERS *pParameters) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetFilterParameters(&This->IXAudio2SourceVoice_iface, pParameters); +} + +static HRESULT WINAPI XA23SRC_SetVolume(IXAudio23SourceVoice *iface, + float Volume, UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SetVolume(&This->IXAudio2SourceVoice_iface, + Volume, OperationSet); +} + +static void WINAPI XA23SRC_GetVolume(IXAudio23SourceVoice *iface, + float *pVolume) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetVolume(&This->IXAudio2SourceVoice_iface, pVolume); +} + +static HRESULT WINAPI XA23SRC_SetChannelVolumes(IXAudio23SourceVoice *iface, + UINT32 Channels, const float *pVolumes, UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SetChannelVolumes(&This->IXAudio2SourceVoice_iface, + Channels, pVolumes, OperationSet); +} + +static void WINAPI XA23SRC_GetChannelVolumes(IXAudio23SourceVoice *iface, + UINT32 Channels, float *pVolumes) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetChannelVolumes(&This->IXAudio2SourceVoice_iface, + Channels, pVolumes); +} + +static HRESULT WINAPI XA23SRC_SetOutputMatrix(IXAudio23SourceVoice *iface, + IXAudio2Voice *pDestinationVoice, UINT32 SourceChannels, + UINT32 DestinationChannels, const float *pLevelMatrix, + UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SetOutputMatrix(&This->IXAudio2SourceVoice_iface, + pDestinationVoice, SourceChannels, DestinationChannels, + pLevelMatrix, OperationSet); +} + +static void WINAPI XA23SRC_GetOutputMatrix(IXAudio23SourceVoice *iface, + IXAudio2Voice *pDestinationVoice, UINT32 SourceChannels, + UINT32 DestinationChannels, float *pLevelMatrix) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetOutputMatrix(&This->IXAudio2SourceVoice_iface, + pDestinationVoice, SourceChannels, DestinationChannels, + pLevelMatrix); +} + +static void WINAPI XA23SRC_DestroyVoice(IXAudio23SourceVoice *iface) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_DestroyVoice(&This->IXAudio2SourceVoice_iface); +} + +static HRESULT WINAPI XA23SRC_Start(IXAudio23SourceVoice *iface, UINT32 Flags, + UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_Start(&This->IXAudio2SourceVoice_iface, Flags, OperationSet); +} + +static HRESULT WINAPI XA23SRC_Stop(IXAudio23SourceVoice *iface, UINT32 Flags, + UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_Stop(&This->IXAudio2SourceVoice_iface, Flags, OperationSet); +} + +static HRESULT WINAPI XA23SRC_SubmitSourceBuffer(IXAudio23SourceVoice *iface, + const XAUDIO2_BUFFER *pBuffer, const XAUDIO2_BUFFER_WMA *pBufferWMA) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SubmitSourceBuffer(&This->IXAudio2SourceVoice_iface, + pBuffer, pBufferWMA); +} + +static HRESULT WINAPI XA23SRC_FlushSourceBuffers(IXAudio23SourceVoice *iface) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_FlushSourceBuffers(&This->IXAudio2SourceVoice_iface); +} + +static HRESULT WINAPI XA23SRC_Discontinuity(IXAudio23SourceVoice *iface) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_Discontinuity(&This->IXAudio2SourceVoice_iface); +} + +static HRESULT WINAPI XA23SRC_ExitLoop(IXAudio23SourceVoice *iface, + UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_ExitLoop(&This->IXAudio2SourceVoice_iface, OperationSet); +} + +static void WINAPI XA23SRC_GetState(IXAudio23SourceVoice *iface, + XAUDIO2_VOICE_STATE *pVoiceState) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetState(&This->IXAudio2SourceVoice_iface, pVoiceState, 0); +} + +static HRESULT WINAPI XA23SRC_SetFrequencyRatio(IXAudio23SourceVoice *iface, + float Ratio, UINT32 OperationSet) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_SetFrequencyRatio(&This->IXAudio2SourceVoice_iface, + Ratio, OperationSet); +} + +static void WINAPI XA23SRC_GetFrequencyRatio(IXAudio23SourceVoice *iface, + float *pRatio) +{ + XA2SourceImpl *This = impl_from_IXAudio23SourceVoice(iface); + return IXAudio2SourceVoice_GetFrequencyRatio(&This->IXAudio2SourceVoice_iface, pRatio); +} + +const IXAudio23SourceVoiceVtbl XAudio23SourceVoice_Vtbl = { + XA23SRC_GetVoiceDetails, + XA23SRC_SetOutputVoices, + XA23SRC_SetEffectChain, + XA23SRC_EnableEffect, + XA23SRC_DisableEffect, + XA23SRC_GetEffectState, + XA23SRC_SetEffectParameters, + XA23SRC_GetEffectParameters, + XA23SRC_SetFilterParameters, + XA23SRC_GetFilterParameters, + XA23SRC_SetVolume, + XA23SRC_GetVolume, + XA23SRC_SetChannelVolumes, + XA23SRC_GetChannelVolumes, + XA23SRC_SetOutputMatrix, + XA23SRC_GetOutputMatrix, + XA23SRC_DestroyVoice, + XA23SRC_Start, + XA23SRC_Stop, + XA23SRC_SubmitSourceBuffer, + XA23SRC_FlushSourceBuffers, + XA23SRC_Discontinuity, + XA23SRC_ExitLoop, + XA23SRC_GetState, + XA23SRC_SetFrequencyRatio, + XA23SRC_GetFrequencyRatio, +}; + +XA2SubmixImpl *impl_from_IXAudio23SubmixVoice(IXAudio23SubmixVoice *iface) +{ + return CONTAINING_RECORD(iface, XA2SubmixImpl, IXAudio23SubmixVoice_iface); +} + +static void WINAPI XA23SUB_GetVoiceDetails(IXAudio23SubmixVoice *iface, + XAUDIO2_VOICE_DETAILS *pVoiceDetails) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_GetVoiceDetails(&This->IXAudio2SubmixVoice_iface, pVoiceDetails); +} + +static HRESULT WINAPI XA23SUB_SetOutputVoices(IXAudio23SubmixVoice *iface, + const XAUDIO23_VOICE_SENDS *pSendList) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + XAUDIO2_VOICE_SENDS sends; + HRESULT hr; + DWORD i; + + TRACE("%p, %p\n", This, pSendList); + + sends.SendCount = pSendList->OutputCount; + sends.pSends = HeapAlloc(GetProcessHeap(), 0, sends.SendCount * sizeof(*sends.pSends)); + for(i = 0; i < sends.SendCount; ++i){ + sends.pSends[i].Flags = 0; + sends.pSends[i].pOutputVoice = pSendList->pOutputVoices[i]; + } + + hr = IXAudio2SubmixVoice_SetOutputVoices(&This->IXAudio2SubmixVoice_iface, &sends); + + HeapFree(GetProcessHeap(), 0, sends.pSends); + + return hr; +} + +static HRESULT WINAPI XA23SUB_SetEffectChain(IXAudio23SubmixVoice *iface, + const XAUDIO2_EFFECT_CHAIN *pEffectChain) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_SetEffectChain(&This->IXAudio2SubmixVoice_iface, pEffectChain); +} + +static HRESULT WINAPI XA23SUB_EnableEffect(IXAudio23SubmixVoice *iface, + UINT32 EffectIndex, UINT32 OperationSet) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_EnableEffect(&This->IXAudio2SubmixVoice_iface, + EffectIndex, OperationSet); +} + +static HRESULT WINAPI XA23SUB_DisableEffect(IXAudio23SubmixVoice *iface, + UINT32 EffectIndex, UINT32 OperationSet) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_DisableEffect(&This->IXAudio2SubmixVoice_iface, + EffectIndex, OperationSet); +} + +static void WINAPI XA23SUB_GetEffectState(IXAudio23SubmixVoice *iface, + UINT32 EffectIndex, BOOL *pEnabled) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_GetEffectState(&This->IXAudio2SubmixVoice_iface, + EffectIndex, pEnabled); +} + +static HRESULT WINAPI XA23SUB_SetEffectParameters(IXAudio23SubmixVoice *iface, + UINT32 EffectIndex, const void *pParameters, UINT32 ParametersByteSize, + UINT32 OperationSet) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_SetEffectParameters(&This->IXAudio2SubmixVoice_iface, + EffectIndex, pParameters, ParametersByteSize, OperationSet); +} + +static HRESULT WINAPI XA23SUB_GetEffectParameters(IXAudio23SubmixVoice *iface, + UINT32 EffectIndex, void *pParameters, UINT32 ParametersByteSize) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_GetEffectParameters(&This->IXAudio2SubmixVoice_iface, + EffectIndex, pParameters, ParametersByteSize); +} + +static HRESULT WINAPI XA23SUB_SetFilterParameters(IXAudio23SubmixVoice *iface, + const XAUDIO2_FILTER_PARAMETERS *pParameters, UINT32 OperationSet) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_SetFilterParameters(&This->IXAudio2SubmixVoice_iface, + pParameters, OperationSet); +} + +static void WINAPI XA23SUB_GetFilterParameters(IXAudio23SubmixVoice *iface, + XAUDIO2_FILTER_PARAMETERS *pParameters) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_GetFilterParameters(&This->IXAudio2SubmixVoice_iface, pParameters); +} + +static HRESULT WINAPI XA23SUB_SetVolume(IXAudio23SubmixVoice *iface, + float Volume, UINT32 OperationSet) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_SetVolume(&This->IXAudio2SubmixVoice_iface, + Volume, OperationSet); +} + +static void WINAPI XA23SUB_GetVolume(IXAudio23SubmixVoice *iface, + float *pVolume) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_GetVolume(&This->IXAudio2SubmixVoice_iface, pVolume); +} + +static HRESULT WINAPI XA23SUB_SetChannelVolumes(IXAudio23SubmixVoice *iface, + UINT32 Channels, const float *pVolumes, UINT32 OperationSet) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_SetChannelVolumes(&This->IXAudio2SubmixVoice_iface, + Channels, pVolumes, OperationSet); +} + +static void WINAPI XA23SUB_GetChannelVolumes(IXAudio23SubmixVoice *iface, + UINT32 Channels, float *pVolumes) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_GetChannelVolumes(&This->IXAudio2SubmixVoice_iface, + Channels, pVolumes); +} + +static HRESULT WINAPI XA23SUB_SetOutputMatrix(IXAudio23SubmixVoice *iface, + IXAudio2Voice *pDestinationVoice, UINT32 SubmixChannels, + UINT32 DestinationChannels, const float *pLevelMatrix, + UINT32 OperationSet) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_SetOutputMatrix(&This->IXAudio2SubmixVoice_iface, + pDestinationVoice, SubmixChannels, DestinationChannels, + pLevelMatrix, OperationSet); +} + +static void WINAPI XA23SUB_GetOutputMatrix(IXAudio23SubmixVoice *iface, + IXAudio2Voice *pDestinationVoice, UINT32 SubmixChannels, + UINT32 DestinationChannels, float *pLevelMatrix) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_GetOutputMatrix(&This->IXAudio2SubmixVoice_iface, + pDestinationVoice, SubmixChannels, DestinationChannels, + pLevelMatrix); +} + +static void WINAPI XA23SUB_DestroyVoice(IXAudio23SubmixVoice *iface) +{ + XA2SubmixImpl *This = impl_from_IXAudio23SubmixVoice(iface); + return IXAudio2SubmixVoice_DestroyVoice(&This->IXAudio2SubmixVoice_iface); +} + +const IXAudio23SubmixVoiceVtbl XAudio23SubmixVoice_Vtbl = { + XA23SUB_GetVoiceDetails, + XA23SUB_SetOutputVoices, + XA23SUB_SetEffectChain, + XA23SUB_EnableEffect, + XA23SUB_DisableEffect, + XA23SUB_GetEffectState, + XA23SUB_SetEffectParameters, + XA23SUB_GetEffectParameters, + XA23SUB_SetFilterParameters, + XA23SUB_GetFilterParameters, + XA23SUB_SetVolume, + XA23SUB_GetVolume, + XA23SUB_SetChannelVolumes, + XA23SUB_GetChannelVolumes, + XA23SUB_SetOutputMatrix, + XA23SUB_GetOutputMatrix, + XA23SUB_DestroyVoice +}; + +IXAudio2Impl *impl_from_IXAudio23MasteringVoice(IXAudio23MasteringVoice *iface) +{ + return CONTAINING_RECORD(iface, IXAudio2Impl, IXAudio23MasteringVoice_iface); +} + +static void WINAPI XA23M_GetVoiceDetails(IXAudio23MasteringVoice *iface, + XAUDIO2_VOICE_DETAILS *pVoiceDetails) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_GetVoiceDetails(&This->IXAudio2MasteringVoice_iface, pVoiceDetails); +} + +static HRESULT WINAPI XA23M_SetOutputVoices(IXAudio23MasteringVoice *iface, + const XAUDIO23_VOICE_SENDS *pSendList) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + XAUDIO2_VOICE_SENDS sends; + HRESULT hr; + DWORD i; + + TRACE("%p, %p\n", This, pSendList); + + sends.SendCount = pSendList->OutputCount; + sends.pSends = HeapAlloc(GetProcessHeap(), 0, sends.SendCount * sizeof(*sends.pSends)); + for(i = 0; i < sends.SendCount; ++i){ + sends.pSends[i].Flags = 0; + sends.pSends[i].pOutputVoice = pSendList->pOutputVoices[i]; + } + + hr = IXAudio2MasteringVoice_SetOutputVoices(&This->IXAudio2MasteringVoice_iface, &sends); + + HeapFree(GetProcessHeap(), 0, sends.pSends); + + return hr; +} + +static HRESULT WINAPI XA23M_SetEffectChain(IXAudio23MasteringVoice *iface, + const XAUDIO2_EFFECT_CHAIN *pEffectChain) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_SetEffectChain(&This->IXAudio2MasteringVoice_iface, pEffectChain); +} + +static HRESULT WINAPI XA23M_EnableEffect(IXAudio23MasteringVoice *iface, + UINT32 EffectIndex, UINT32 OperationSet) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_EnableEffect(&This->IXAudio2MasteringVoice_iface, + EffectIndex, OperationSet); +} + +static HRESULT WINAPI XA23M_DisableEffect(IXAudio23MasteringVoice *iface, + UINT32 EffectIndex, UINT32 OperationSet) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_DisableEffect(&This->IXAudio2MasteringVoice_iface, + EffectIndex, OperationSet); +} + +static void WINAPI XA23M_GetEffectState(IXAudio23MasteringVoice *iface, + UINT32 EffectIndex, BOOL *pEnabled) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_GetEffectState(&This->IXAudio2MasteringVoice_iface, + EffectIndex, pEnabled); +} + +static HRESULT WINAPI XA23M_SetEffectParameters(IXAudio23MasteringVoice *iface, + UINT32 EffectIndex, const void *pParameters, UINT32 ParametersByteSize, + UINT32 OperationSet) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_SetEffectParameters(&This->IXAudio2MasteringVoice_iface, + EffectIndex, pParameters, ParametersByteSize, OperationSet); +} + +static HRESULT WINAPI XA23M_GetEffectParameters(IXAudio23MasteringVoice *iface, + UINT32 EffectIndex, void *pParameters, UINT32 ParametersByteSize) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_GetEffectParameters(&This->IXAudio2MasteringVoice_iface, + EffectIndex, pParameters, ParametersByteSize); +} + +static HRESULT WINAPI XA23M_SetFilterParameters(IXAudio23MasteringVoice *iface, + const XAUDIO2_FILTER_PARAMETERS *pParameters, UINT32 OperationSet) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_SetFilterParameters(&This->IXAudio2MasteringVoice_iface, + pParameters, OperationSet); +} + +static void WINAPI XA23M_GetFilterParameters(IXAudio23MasteringVoice *iface, + XAUDIO2_FILTER_PARAMETERS *pParameters) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_GetFilterParameters(&This->IXAudio2MasteringVoice_iface, pParameters); +} + +static HRESULT WINAPI XA23M_SetVolume(IXAudio23MasteringVoice *iface, + float Volume, UINT32 OperationSet) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_SetVolume(&This->IXAudio2MasteringVoice_iface, + Volume, OperationSet); +} + +static void WINAPI XA23M_GetVolume(IXAudio23MasteringVoice *iface, + float *pVolume) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_GetVolume(&This->IXAudio2MasteringVoice_iface, pVolume); +} + +static HRESULT WINAPI XA23M_SetChannelVolumes(IXAudio23MasteringVoice *iface, + UINT32 Channels, const float *pVolumes, UINT32 OperationSet) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_SetChannelVolumes(&This->IXAudio2MasteringVoice_iface, + Channels, pVolumes, OperationSet); +} + +static void WINAPI XA23M_GetChannelVolumes(IXAudio23MasteringVoice *iface, + UINT32 Channels, float *pVolumes) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_GetChannelVolumes(&This->IXAudio2MasteringVoice_iface, + Channels, pVolumes); +} + +static HRESULT WINAPI XA23M_SetOutputMatrix(IXAudio23MasteringVoice *iface, + IXAudio2Voice *pDestinationVoice, UINT32 MasteringChannels, + UINT32 DestinationChannels, const float *pLevelMatrix, + UINT32 OperationSet) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_SetOutputMatrix(&This->IXAudio2MasteringVoice_iface, + pDestinationVoice, MasteringChannels, DestinationChannels, + pLevelMatrix, OperationSet); +} + +static void WINAPI XA23M_GetOutputMatrix(IXAudio23MasteringVoice *iface, + IXAudio2Voice *pDestinationVoice, UINT32 MasteringChannels, + UINT32 DestinationChannels, float *pLevelMatrix) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_GetOutputMatrix(&This->IXAudio2MasteringVoice_iface, + pDestinationVoice, MasteringChannels, DestinationChannels, + pLevelMatrix); +} + +static void WINAPI XA23M_DestroyVoice(IXAudio23MasteringVoice *iface) +{ + IXAudio2Impl *This = impl_from_IXAudio23MasteringVoice(iface); + return IXAudio2MasteringVoice_DestroyVoice(&This->IXAudio2MasteringVoice_iface); +} + +const IXAudio23MasteringVoiceVtbl XAudio23MasteringVoice_Vtbl = { + XA23M_GetVoiceDetails, + XA23M_SetOutputVoices, + XA23M_SetEffectChain, + XA23M_EnableEffect, + XA23M_DisableEffect, + XA23M_GetEffectState, + XA23M_SetEffectParameters, + XA23M_GetEffectParameters, + XA23M_SetFilterParameters, + XA23M_GetFilterParameters, + XA23M_SetVolume, + XA23M_GetVolume, + XA23M_SetChannelVolumes, + XA23M_GetChannelVolumes, + XA23M_SetOutputMatrix, + XA23M_GetOutputMatrix, + XA23M_DestroyVoice +}; diff --git a/dlls/xaudio2_7/xaudio_dll.c b/dlls/xaudio2_7/xaudio_dll.c index 16865486fc5..ed5ef494a83 100644 --- a/dlls/xaudio2_7/xaudio_dll.c +++ b/dlls/xaudio2_7/xaudio_dll.c @@ -1348,6 +1348,7 @@ static HRESULT WINAPI IXAudio2Impl_CreateSourceVoice(IXAudio2 *iface, list_add_head(&This->source_voices, &src->entry); + src->IXAudio23SourceVoice_iface.lpVtbl = &XAudio23SourceVoice_Vtbl; src->IXAudio27SourceVoice_iface.lpVtbl = &XAudio27SourceVoice_Vtbl; src->IXAudio2SourceVoice_iface.lpVtbl = &XAudio2SourceVoice_Vtbl; @@ -1386,7 +1387,9 @@ static HRESULT WINAPI IXAudio2Impl_CreateSourceVoice(IXAudio2 *iface, alSourcePlay(src->al_src); - if(This->version == 27) + if(This->version <= 23) + *ppSourceVoice = (IXAudio2SourceVoice*)&src->IXAudio23SourceVoice_iface; + else if(This->version <= 27) *ppSourceVoice = (IXAudio2SourceVoice*)&src->IXAudio27SourceVoice_iface; else *ppSourceVoice = &src->IXAudio2SourceVoice_iface; @@ -1425,6 +1428,7 @@ static HRESULT WINAPI IXAudio2Impl_CreateSubmixVoice(IXAudio2 *iface, list_add_head(&This->submix_voices, &sub->entry); + sub->IXAudio23SubmixVoice_iface.lpVtbl = &XAudio23SubmixVoice_Vtbl; sub->IXAudio2SubmixVoice_iface.lpVtbl = &XAudio2SubmixVoice_Vtbl; InitializeCriticalSection(&sub->lock); @@ -1435,7 +1439,10 @@ static HRESULT WINAPI IXAudio2Impl_CreateSubmixVoice(IXAudio2 *iface, LeaveCriticalSection(&This->lock); - *ppSubmixVoice = &sub->IXAudio2SubmixVoice_iface; + if(This->version <= 23) + *ppSubmixVoice = (IXAudio2SubmixVoice*)&sub->IXAudio23SubmixVoice_iface; + else + *ppSubmixVoice = &sub->IXAudio2SubmixVoice_iface; TRACE("Created submix voice: %p\n", sub); @@ -1658,7 +1665,10 @@ static HRESULT WINAPI IXAudio2Impl_CreateMasteringVoice(IXAudio2 *iface, IAudioClient_Start(This->aclient); - *ppMasteringVoice = &This->IXAudio2MasteringVoice_iface; + if(This->version <= 23) + *ppMasteringVoice = (IXAudio2MasteringVoice*)&This->IXAudio23MasteringVoice_iface; + else + *ppMasteringVoice = &This->IXAudio2MasteringVoice_iface; exit: if(FAILED(hr)){ @@ -2159,6 +2169,17 @@ static const IXAPOParametersVtbl RVBXAPOParameters_Vtbl = { RVBXAPOParams_GetParameters }; +struct xaudio2_cf { + IClassFactory IClassFactory_iface; + LONG ref; + DWORD version; +}; + +struct xaudio2_cf *impl_from_IClassFactory(IClassFactory *iface) +{ + return CONTAINING_RECORD(iface, struct xaudio2_cf, IClassFactory_iface); +} + static HRESULT WINAPI XAudio2CF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppobj) { if(IsEqualGUID(riid, &IID_IUnknown) @@ -2176,12 +2197,20 @@ static HRESULT WINAPI XAudio2CF_QueryInterface(IClassFactory *iface, REFIID riid static ULONG WINAPI XAudio2CF_AddRef(IClassFactory *iface) { - return 2; + struct xaudio2_cf *This = impl_from_IClassFactory(iface); + ULONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p)->(): Refcount now %u\n", This, ref); + return ref; } static ULONG WINAPI XAudio2CF_Release(IClassFactory *iface) { - return 1; + struct xaudio2_cf *This = impl_from_IClassFactory(iface); + ULONG ref = InterlockedDecrement(&This->ref); + TRACE("(%p)->(): Refcount now %u\n", This, ref); + if (!ref) + HeapFree(GetProcessHeap(), 0, This); + return ref; } static HRESULT initialize_mmdevices(IXAudio2Impl *This) @@ -2260,10 +2289,11 @@ static HRESULT initialize_mmdevices(IXAudio2Impl *This) static HRESULT WINAPI XAudio2CF_CreateInstance(IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppobj) { + struct xaudio2_cf *This = impl_from_IClassFactory(iface); HRESULT hr; IXAudio2Impl *object; - TRACE("(static)->(%p,%s,%p)\n", pOuter, debugstr_guid(riid), ppobj); + TRACE("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj); *ppobj = NULL; @@ -2276,11 +2306,12 @@ static HRESULT WINAPI XAudio2CF_CreateInstance(IClassFactory *iface, IUnknown *p object->IXAudio27_iface.lpVtbl = &XAudio27_Vtbl; object->IXAudio2_iface.lpVtbl = &XAudio2_Vtbl; + object->IXAudio23MasteringVoice_iface.lpVtbl = &XAudio23MasteringVoice_Vtbl; object->IXAudio2MasteringVoice_iface.lpVtbl = &XAudio2MasteringVoice_Vtbl; if(IsEqualGUID(riid, &IID_IXAudio27)) - object->version = 27; - else + object->version = This->version; + else /* only xaudio 2.8 has a different IID */ object->version = 28; list_init(&object->source_voices); @@ -2310,6 +2341,16 @@ static HRESULT WINAPI XAudio2CF_CreateInstance(IClassFactory *iface, IUnknown *p return hr; } +static ULONG WINAPI static_AddRef(IClassFactory *iface) +{ + return 2; +} + +static ULONG WINAPI static_Release(IClassFactory *iface) +{ + return 1; +} + static HRESULT WINAPI VUMeterCF_CreateInstance(IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppobj) { @@ -2386,8 +2427,8 @@ static const IClassFactoryVtbl XAudio2CF_Vtbl = static const IClassFactoryVtbl VUMeterCF_Vtbl = { XAudio2CF_QueryInterface, - XAudio2CF_AddRef, - XAudio2CF_Release, + static_AddRef, + static_Release, VUMeterCF_CreateInstance, XAudio2CF_LockServer }; @@ -2395,24 +2436,34 @@ static const IClassFactoryVtbl VUMeterCF_Vtbl = static const IClassFactoryVtbl ReverbCF_Vtbl = { XAudio2CF_QueryInterface, - XAudio2CF_AddRef, - XAudio2CF_Release, + static_AddRef, + static_Release, ReverbCF_CreateInstance, XAudio2CF_LockServer }; -static IClassFactory xaudio2_cf = { &XAudio2CF_Vtbl }; static IClassFactory vumeter_cf = { &VUMeterCF_Vtbl }; static IClassFactory reverb_cf = { &ReverbCF_Vtbl }; +static IClassFactory *make_xaudio2_factory(DWORD version) +{ + struct xaudio2_cf *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(struct xaudio2_cf)); + ret->IClassFactory_iface.lpVtbl = &XAudio2CF_Vtbl; + ret->version = version; + ret->ref = 0; + return &ret->IClassFactory_iface; +} + HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv) { IClassFactory *factory = NULL; TRACE("(%s, %s, %p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); - if(IsEqualGUID(rclsid, &CLSID_XAudio2)) { - factory = &xaudio2_cf; + if IsEqualGUID(rclsid, &CLSID_XAudio23){ + factory = make_xaudio2_factory(23); + }else if(IsEqualGUID(rclsid, &CLSID_XAudio2)){ + factory = make_xaudio2_factory(27); }else if(IsEqualGUID(rclsid, &CLSID_AudioVolumeMeter)) { factory = &vumeter_cf; }else if(IsEqualGUID(rclsid, &CLSID_AudioReverb)) { diff --git a/dlls/xaudio2_7/xaudio_private.h b/dlls/xaudio2_7/xaudio_private.h index 317b0fa16af..5a0fcdfe9ae 100644 --- a/dlls/xaudio2_7/xaudio_private.h +++ b/dlls/xaudio2_7/xaudio_private.h @@ -42,6 +42,7 @@ typedef struct _XA2Buffer { typedef struct _IXAudio2Impl IXAudio2Impl; typedef struct _XA2SourceImpl { + IXAudio23SourceVoice IXAudio23SourceVoice_iface; IXAudio27SourceVoice IXAudio27SourceVoice_iface; IXAudio2SourceVoice IXAudio2SourceVoice_iface; @@ -80,6 +81,7 @@ typedef struct _XA2SourceImpl { } XA2SourceImpl; typedef struct _XA2SubmixImpl { + IXAudio23SubmixVoice IXAudio23SubmixVoice_iface; IXAudio2SubmixVoice IXAudio2SubmixVoice_iface; BOOL in_use; @@ -92,6 +94,7 @@ typedef struct _XA2SubmixImpl { struct _IXAudio2Impl { IXAudio27 IXAudio27_iface; IXAudio2 IXAudio2_iface; + IXAudio23MasteringVoice IXAudio23MasteringVoice_iface; IXAudio2MasteringVoice IXAudio2MasteringVoice_iface; LONG ref; @@ -129,3 +132,7 @@ struct _IXAudio2Impl { extern const IXAudio27SourceVoiceVtbl XAudio27SourceVoice_Vtbl DECLSPEC_HIDDEN; extern const IXAudio27Vtbl XAudio27_Vtbl DECLSPEC_HIDDEN; + +extern const IXAudio23SourceVoiceVtbl XAudio23SourceVoice_Vtbl DECLSPEC_HIDDEN; +extern const IXAudio23SubmixVoiceVtbl XAudio23SubmixVoice_Vtbl DECLSPEC_HIDDEN; +extern const IXAudio23MasteringVoiceVtbl XAudio23MasteringVoice_Vtbl DECLSPEC_HIDDEN; diff --git a/include/xaudio2.idl b/include/xaudio2.idl index 3ac3e221adb..1730648765b 100644 --- a/include/xaudio2.idl +++ b/include/xaudio2.idl @@ -30,6 +30,13 @@ coclass XAudio2 { interface IUnknown; } +[ + uuid(4c5e637a-16c7-4de3-9c46-5ed22181962d) +] +coclass XAudio23 { + interface IUnknown; +} + [ uuid(db05ea35-0329-4d4b-a53a-6dead03d3852) ] @@ -153,6 +160,13 @@ typedef struct XAUDIO2_SEND_DESCRIPTOR IXAudio2Voice* pOutputVoice; } XAUDIO2_SEND_DESCRIPTOR; +/* XAudio2 2.3's XAUDIO2_VOICE_SENDS struct */ +typedef struct XAUDIO23_VOICE_SENDS +{ + UINT32 OutputCount; + IXAudio2Voice **pOutputVoices; +} XAUDIO23_VOICE_SENDS; + typedef struct XAUDIO2_VOICE_SENDS { UINT32 SendCount; @@ -222,6 +236,80 @@ typedef struct XAUDIO2_FILTER_PARAMETERS float OneOverQ; } XAUDIO2_FILTER_PARAMETERS; +/* XAudio 2.3's IXAudio2Voice */ +/* XAudio2 2.3's IXAudio2Voice interface. Actually called + * IXAudio2Voice in the Nov 2008 DX SDK */ +[ + object, + local +] +interface IXAudio23Voice +{ + void GetVoiceDetails([out] XAUDIO2_VOICE_DETAILS* pVoiceDetails); + + HRESULT SetOutputVoices([in] const XAUDIO23_VOICE_SENDS* pSendList); + + HRESULT SetEffectChain([in] const XAUDIO2_EFFECT_CHAIN* pEffectChain); + + HRESULT EnableEffect( + [in] UINT32 EffectIndex, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + HRESULT DisableEffect( + [in] UINT32 EffectIndex, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + void GetEffectState( + [in] UINT32 EffectIndex, + [out] BOOL* pEnabled); + + HRESULT SetEffectParameters( + [in] UINT32 EffectIndex, + [in] const void* pParameters, + [in] UINT32 ParametersByteSize, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + HRESULT GetEffectParameters( + [in] UINT32 EffectIndex, + [out] void* pParameters, + [in] UINT32 ParametersByteSize); + + HRESULT SetFilterParameters( + [in] const XAUDIO2_FILTER_PARAMETERS* pParameters, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + void GetFilterParameters([out] XAUDIO2_FILTER_PARAMETERS* pParameters); + + HRESULT SetVolume( + [in] float Volume, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + void GetVolume([out] float* pVolume); + + HRESULT SetChannelVolumes( + [in] UINT32 Channels, + [in, size_is(Channels)] const float* pVolumes, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + void GetChannelVolumes( + [in] UINT32 Channels, + [out, size_is(Channels)] float* pVolumes); + + HRESULT SetOutputMatrix( + [in] IXAudio2Voice* pDestinationVoice, + [in] UINT32 SourceChannels, + [in] UINT32 DestinationChannels, + [in, size_is(SourceChannels * DestinationChannels)] const float* pLevelMatrix, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + void GetOutputMatrix( + [in] IXAudio2Voice* pDestinationVoice, + [in] UINT32 SourceChannels, + [in] UINT32 DestinationChannels, + [out, size_is(SourceChannels * DestinationChannels)] float* pLevelMatrix); + + void DestroyVoice(); +} [ object, local @@ -329,6 +417,40 @@ typedef struct XAUDIO2_VOICE_STATE UINT64 SamplesPlayed; } XAUDIO2_VOICE_STATE; +[ + local +] +/* XAudio2 2.3's IXAudio2SourceVoice interface. Actually called + * IXAudio2SourceVoice in the Nov 2008 DX SDK */ +interface IXAudio23SourceVoice : IXAudio23Voice +{ + HRESULT Start( + [in, defaultvalue(0)] UINT32 Flags, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + HRESULT Stop( + [in, defaultvalue(0)] UINT32 Flags, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + HRESULT SubmitSourceBuffer( + [in] const XAUDIO2_BUFFER* pBuffer, + [in, defaultvalue(NULL)] const XAUDIO2_BUFFER_WMA* pBufferWMA); + + HRESULT FlushSourceBuffers(); + + HRESULT Discontinuity(); + + HRESULT ExitLoop([in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + void GetState([out] XAUDIO2_VOICE_STATE* pVoiceState); + + HRESULT SetFrequencyRatio( + [in] float Ratio, + [in, defaultvalue(XAUDIO2_COMMIT_NOW)] UINT32 OperationSet); + + void GetFrequencyRatio([out] float* pRatio); +} + [ local ] @@ -400,6 +522,15 @@ interface IXAudio2SourceVoice : IXAudio2Voice HRESULT SetSourceSampleRate([in] UINT32 NewSourceSampleRate); } +[ + local +] +/* XAudio2 2.3's IXAudio2SubmixVoice interface. Actually called + * IXAudio2SubmixVoice in the Nov 2008 DX SDK */ +interface IXAudio23SubmixVoice : IXAudio23Voice +{ +} + [ local ] @@ -407,6 +538,15 @@ interface IXAudio2SubmixVoice : IXAudio2Voice { } +[ + local +] +/* XAudio2 2.3's IXAudio2MasteringVoice interface. Actually called + * IXAudio2MasteringVoice in the Nov 2008 DX SDK */ +interface IXAudio23MasteringVoice : IXAudio23Voice +{ +} + [ local ]