system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-09-19 21:48:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

dsound: Inline some of the IDirectSound helpers.

Browse source
This commit is contained in:
Michael Stefaniuc 2012-09-05 23:19:12 +02:00 committed by Alexandre Julliard
parent 823d1fbc38
commit 1440b25267
2 changed files with 113 additions and 175 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

274
dlls/dsound/dsound.c
View file

@ -242,11 +242,54 @@ static HRESULT WINAPI IDirectSound8Impl_CreateSoundBuffer(IDirectSound8 *iface,
return DirectSoundDevice_CreateSoundBuffer(This->device, dsbd, ppdsb, lpunk, This->has_ds8); return DirectSoundDevice_CreateSoundBuffer(This->device, dsbd, ppdsb, lpunk, This->has_ds8);
} }
static HRESULT WINAPI IDirectSound8Impl_GetCaps(IDirectSound8 *iface, DSCAPS *lpDSCaps) static HRESULT WINAPI IDirectSound8Impl_GetCaps(IDirectSound8 *iface, DSCAPS *dscaps)
{ {
IDirectSoundImpl *This = impl_from_IDirectSound8(iface); IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
TRACE("(%p,%p)\n", This, lpDSCaps);
return DirectSoundDevice_GetCaps(This->device, lpDSCaps); TRACE("(%p, %p)\n", This, dscaps);
if (!This->device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (!dscaps) {
WARN("invalid parameter: dscaps = NULL\n");
return DSERR_INVALIDPARAM;
}
if (dscaps->dwSize < sizeof(*dscaps)) {
WARN("invalid parameter: dscaps->dwSize = %d\n", dscaps->dwSize);
return DSERR_INVALIDPARAM;
}
dscaps->dwFlags = This->device->drvcaps.dwFlags;
dscaps->dwMinSecondarySampleRate = This->device->drvcaps.dwMinSecondarySampleRate;
dscaps->dwMaxSecondarySampleRate = This->device->drvcaps.dwMaxSecondarySampleRate;
dscaps->dwPrimaryBuffers = This->device->drvcaps.dwPrimaryBuffers;
dscaps->dwMaxHwMixingAllBuffers = This->device->drvcaps.dwMaxHwMixingAllBuffers;
dscaps->dwMaxHwMixingStaticBuffers = This->device->drvcaps.dwMaxHwMixingStaticBuffers;
dscaps->dwMaxHwMixingStreamingBuffers = This->device->drvcaps.dwMaxHwMixingStreamingBuffers;
dscaps->dwFreeHwMixingAllBuffers = This->device->drvcaps.dwFreeHwMixingAllBuffers;
dscaps->dwFreeHwMixingStaticBuffers = This->device->drvcaps.dwFreeHwMixingStaticBuffers;
dscaps->dwFreeHwMixingStreamingBuffers = This->device->drvcaps.dwFreeHwMixingStreamingBuffers;
dscaps->dwMaxHw3DAllBuffers = This->device->drvcaps.dwMaxHw3DAllBuffers;
dscaps->dwMaxHw3DStaticBuffers = This->device->drvcaps.dwMaxHw3DStaticBuffers;
dscaps->dwMaxHw3DStreamingBuffers = This->device->drvcaps.dwMaxHw3DStreamingBuffers;
dscaps->dwFreeHw3DAllBuffers = This->device->drvcaps.dwFreeHw3DAllBuffers;
dscaps->dwFreeHw3DStaticBuffers = This->device->drvcaps.dwFreeHw3DStaticBuffers;
dscaps->dwFreeHw3DStreamingBuffers = This->device->drvcaps.dwFreeHw3DStreamingBuffers;
dscaps->dwTotalHwMemBytes = This->device->drvcaps.dwTotalHwMemBytes;
dscaps->dwFreeHwMemBytes = This->device->drvcaps.dwFreeHwMemBytes;
dscaps->dwMaxContigFreeHwMemBytes = This->device->drvcaps.dwMaxContigFreeHwMemBytes;
dscaps->dwUnlockTransferRateHwBuffers = This->device->drvcaps.dwUnlockTransferRateHwBuffers;
dscaps->dwPlayCpuOverheadSwBuffers = This->device->drvcaps.dwPlayCpuOverheadSwBuffers;
if (TRACE_ON(dsound)) {
TRACE("(flags=0x%08x:\n", dscaps->dwFlags);
_dump_DSCAPS(dscaps->dwFlags);
TRACE(")\n");
}
return DS_OK;
} }
static HRESULT WINAPI IDirectSound8Impl_DuplicateSoundBuffer(IDirectSound8 *iface, static HRESULT WINAPI IDirectSound8Impl_DuplicateSoundBuffer(IDirectSound8 *iface,
@ -261,30 +304,75 @@ static HRESULT WINAPI IDirectSound8Impl_SetCooperativeLevel(IDirectSound8 *iface
DWORD level) DWORD level)
{ {
IDirectSoundImpl *This = impl_from_IDirectSound8(iface); IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
TRACE("(%p,%p,%s)\n", This, hwnd, dumpCooperativeLevel(level)); TRACE("(%p,%p,%s)\n", This, hwnd, dumpCooperativeLevel(level));
return DirectSoundDevice_SetCooperativeLevel(This->device, hwnd, level);
if (!This->device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (level == DSSCL_PRIORITY || level == DSSCL_EXCLUSIVE) {
WARN("level=%s not fully supported\n",
level == DSSCL_PRIORITY ? "DSSCL_PRIORITY" : "DSSCL_EXCLUSIVE");
}
This->device->priolevel = level;
return DS_OK;
} }
static HRESULT WINAPI IDirectSound8Impl_Compact(IDirectSound8 *iface) static HRESULT WINAPI IDirectSound8Impl_Compact(IDirectSound8 *iface)
{ {
IDirectSoundImpl *This = impl_from_IDirectSound8(iface); IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
TRACE("(%p)\n", This); TRACE("(%p)\n", This);
return DirectSoundDevice_Compact(This->device);
if (!This->device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (This->device->priolevel < DSSCL_PRIORITY) {
WARN("incorrect priority level\n");
return DSERR_PRIOLEVELNEEDED;
}
return DS_OK;
} }
static HRESULT WINAPI IDirectSound8Impl_GetSpeakerConfig(IDirectSound8 *iface, static HRESULT WINAPI IDirectSound8Impl_GetSpeakerConfig(IDirectSound8 *iface, DWORD *config)
DWORD *lpdwSpeakerConfig)
{ {
IDirectSoundImpl *This = impl_from_IDirectSound8(iface); IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
return DirectSoundDevice_GetSpeakerConfig(This->device, lpdwSpeakerConfig); TRACE("(%p, %p)\n", This, config);
if (!This->device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (!config) {
WARN("invalid parameter: config == NULL\n");
return DSERR_INVALIDPARAM;
}
WARN("not fully functional\n");
*config = This->device->speaker_config;
return DS_OK;
} }
static HRESULT WINAPI IDirectSound8Impl_SetSpeakerConfig(IDirectSound8 *iface, DWORD config) static HRESULT WINAPI IDirectSound8Impl_SetSpeakerConfig(IDirectSound8 *iface, DWORD config)
{ {
IDirectSoundImpl *This = impl_from_IDirectSound8(iface); IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
TRACE("(%p,0x%08x)\n", This, config); TRACE("(%p,0x%08x)\n", This, config);
return DirectSoundDevice_SetSpeakerConfig(This->device, config);
if (!This->device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
This->device->speaker_config = config;
WARN("not fully functional\n");
return DS_OK;
} }
static HRESULT WINAPI IDirectSound8Impl_Initialize(IDirectSound8 *iface, const GUID *lpcGuid) static HRESULT WINAPI IDirectSound8Impl_Initialize(IDirectSound8 *iface, const GUID *lpcGuid)
@ -294,12 +382,23 @@ static HRESULT WINAPI IDirectSound8Impl_Initialize(IDirectSound8 *iface, const G
return DirectSoundDevice_Initialize(&This->device, lpcGuid); return DirectSoundDevice_Initialize(&This->device, lpcGuid);
} }
static HRESULT WINAPI IDirectSound8Impl_VerifyCertification(IDirectSound8 *iface, static HRESULT WINAPI IDirectSound8Impl_VerifyCertification(IDirectSound8 *iface, DWORD *certified)
DWORD *pdwCertified)
{ {
IDirectSoundImpl *This = impl_from_IDirectSound8(iface); IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
TRACE("(%p, %p)\n", This, pdwCertified);
return DirectSoundDevice_VerifyCertification(This->device, pdwCertified); TRACE("(%p, %p)\n", This, certified);
if (!This->device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (This->device->drvcaps.dwFlags & DSCAPS_CERTIFIED)
*certified = DS_CERTIFIED;
else
*certified = DS_UNCERTIFIED;
return DS_OK;
} }
static const IDirectSound8Vtbl ds8_vtbl = static const IDirectSound8Vtbl ds8_vtbl =
@ -596,58 +695,6 @@ ULONG DirectSoundDevice_Release(DirectSoundDevice * device)
return ref; return ref;
} }
HRESULT DirectSoundDevice_GetCaps(
DirectSoundDevice * device,
LPDSCAPS lpDSCaps)
{
TRACE("(%p,%p)\n",device,lpDSCaps);
if (device == NULL) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (lpDSCaps == NULL) {
WARN("invalid parameter: lpDSCaps = NULL\n");
return DSERR_INVALIDPARAM;
}
/* check if there is enough room */
if (lpDSCaps->dwSize < sizeof(*lpDSCaps)) {
WARN("invalid parameter: lpDSCaps->dwSize = %d\n", lpDSCaps->dwSize);
return DSERR_INVALIDPARAM;
}
lpDSCaps->dwFlags = device->drvcaps.dwFlags;
if (TRACE_ON(dsound)) {
TRACE("(flags=0x%08x:\n",lpDSCaps->dwFlags);
_dump_DSCAPS(lpDSCaps->dwFlags);
TRACE(")\n");
}
lpDSCaps->dwMinSecondarySampleRate = device->drvcaps.dwMinSecondarySampleRate;
lpDSCaps->dwMaxSecondarySampleRate = device->drvcaps.dwMaxSecondarySampleRate;
lpDSCaps->dwPrimaryBuffers = device->drvcaps.dwPrimaryBuffers;
lpDSCaps->dwMaxHwMixingAllBuffers = device->drvcaps.dwMaxHwMixingAllBuffers;
lpDSCaps->dwMaxHwMixingStaticBuffers = device->drvcaps.dwMaxHwMixingStaticBuffers;
lpDSCaps->dwMaxHwMixingStreamingBuffers = device->drvcaps.dwMaxHwMixingStreamingBuffers;
lpDSCaps->dwFreeHwMixingAllBuffers = device->drvcaps.dwFreeHwMixingAllBuffers;
lpDSCaps->dwFreeHwMixingStaticBuffers = device->drvcaps.dwFreeHwMixingStaticBuffers;
lpDSCaps->dwFreeHwMixingStreamingBuffers = device->drvcaps.dwFreeHwMixingStreamingBuffers;
lpDSCaps->dwMaxHw3DAllBuffers = device->drvcaps.dwMaxHw3DAllBuffers;
lpDSCaps->dwMaxHw3DStaticBuffers = device->drvcaps.dwMaxHw3DStaticBuffers;
lpDSCaps->dwMaxHw3DStreamingBuffers = device->drvcaps.dwMaxHw3DStreamingBuffers;
lpDSCaps->dwFreeHw3DAllBuffers = device->drvcaps.dwFreeHw3DAllBuffers;
lpDSCaps->dwFreeHw3DStaticBuffers = device->drvcaps.dwFreeHw3DStaticBuffers;
lpDSCaps->dwFreeHw3DStreamingBuffers = device->drvcaps.dwFreeHw3DStreamingBuffers;
lpDSCaps->dwTotalHwMemBytes = device->drvcaps.dwTotalHwMemBytes;
lpDSCaps->dwFreeHwMemBytes = device->drvcaps.dwFreeHwMemBytes;
lpDSCaps->dwMaxContigFreeHwMemBytes = device->drvcaps.dwMaxContigFreeHwMemBytes;
lpDSCaps->dwUnlockTransferRateHwBuffers = device->drvcaps.dwUnlockTransferRateHwBuffers;
lpDSCaps->dwPlayCpuOverheadSwBuffers = device->drvcaps.dwPlayCpuOverheadSwBuffers;
return DS_OK;
}
BOOL DSOUND_check_supported(IAudioClient *client, DWORD rate, BOOL DSOUND_check_supported(IAudioClient *client, DWORD rate,
DWORD depth, WORD channels) DWORD depth, WORD channels)
{ {
@ -998,101 +1045,6 @@ HRESULT DirectSoundDevice_DuplicateSoundBuffer(
return hres; return hres;
} }
HRESULT DirectSoundDevice_SetCooperativeLevel(
DirectSoundDevice * device,
HWND hwnd,
DWORD level)
{
TRACE("(%p,%p,%s)\n",device,hwnd,dumpCooperativeLevel(level));
if (device == NULL) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (level==DSSCL_PRIORITY || level==DSSCL_EXCLUSIVE) {
WARN("level=%s not fully supported\n",
level==DSSCL_PRIORITY ? "DSSCL_PRIORITY" : "DSSCL_EXCLUSIVE");
}
device->priolevel = level;
return DS_OK;
}
HRESULT DirectSoundDevice_Compact(
DirectSoundDevice * device)
{
TRACE("(%p)\n", device);
if (device == NULL) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (device->priolevel < DSSCL_PRIORITY) {
WARN("incorrect priority level\n");
return DSERR_PRIOLEVELNEEDED;
}
return DS_OK;
}
HRESULT DirectSoundDevice_GetSpeakerConfig(
DirectSoundDevice * device,
LPDWORD lpdwSpeakerConfig)
{
TRACE("(%p, %p)\n", device, lpdwSpeakerConfig);
if (device == NULL) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (lpdwSpeakerConfig == NULL) {
WARN("invalid parameter: lpdwSpeakerConfig == NULL\n");
return DSERR_INVALIDPARAM;
}
WARN("not fully functional\n");
*lpdwSpeakerConfig = device->speaker_config;
return DS_OK;
}
HRESULT DirectSoundDevice_SetSpeakerConfig(
DirectSoundDevice * device,
DWORD config)
{
TRACE("(%p,0x%08x)\n",device,config);
if (device == NULL) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
device->speaker_config = config;
WARN("not fully functional\n");
return DS_OK;
}
HRESULT DirectSoundDevice_VerifyCertification(
DirectSoundDevice * device,
LPDWORD pdwCertified)
{
TRACE("(%p, %p)\n",device,pdwCertified);
if (device == NULL) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (device->drvcaps.dwFlags & DSCAPS_CERTIFIED)
*pdwCertified = DS_CERTIFIED;
else
*pdwCertified = DS_UNCERTIFIED;
return DS_OK;
}
/* /*
* Add secondary buffer to buffer list. * Add secondary buffer to buffer list.
* Gets exclusive access to buffer for writing. * Gets exclusive access to buffer for writing.

14
dlls/dsound/dsound_private.h
View file

@ -121,7 +121,6 @@ HRESULT DirectSoundDevice_AddBuffer(
HRESULT DirectSoundDevice_RemoveBuffer( HRESULT DirectSoundDevice_RemoveBuffer(
DirectSoundDevice * device, DirectSoundDevice * device,
IDirectSoundBufferImpl * pDSB) DECLSPEC_HIDDEN; IDirectSoundBufferImpl * pDSB) DECLSPEC_HIDDEN;
HRESULT DirectSoundDevice_GetCaps(DirectSoundDevice * device, LPDSCAPS lpDSCaps) DECLSPEC_HIDDEN;
HRESULT DirectSoundDevice_CreateSoundBuffer( HRESULT DirectSoundDevice_CreateSoundBuffer(
DirectSoundDevice * device, DirectSoundDevice * device,
LPCDSBUFFERDESC dsbd, LPCDSBUFFERDESC dsbd,
@ -132,19 +131,6 @@ HRESULT DirectSoundDevice_DuplicateSoundBuffer(
DirectSoundDevice * device, DirectSoundDevice * device,
LPDIRECTSOUNDBUFFER psb, LPDIRECTSOUNDBUFFER psb,
LPLPDIRECTSOUNDBUFFER ppdsb) DECLSPEC_HIDDEN; LPLPDIRECTSOUNDBUFFER ppdsb) DECLSPEC_HIDDEN;
HRESULT DirectSoundDevice_SetCooperativeLevel(
DirectSoundDevice * devcie,
HWND hwnd,
DWORD level) DECLSPEC_HIDDEN;
HRESULT DirectSoundDevice_Compact(DirectSoundDevice * device) DECLSPEC_HIDDEN;
HRESULT DirectSoundDevice_GetSpeakerConfig(
DirectSoundDevice * device,
LPDWORD lpdwSpeakerConfig) DECLSPEC_HIDDEN;
HRESULT DirectSoundDevice_SetSpeakerConfig(
DirectSoundDevice * device,
DWORD config) DECLSPEC_HIDDEN;
HRESULT DirectSoundDevice_VerifyCertification(DirectSoundDevice * device,
LPDWORD pdwCertified) DECLSPEC_HIDDEN;
/***************************************************************************** /*****************************************************************************
* IDirectSoundBuffer implementation structure * IDirectSoundBuffer implementation structure