| /* DirectSound |
| * |
| * Copyright 1998 Marcus Meissner |
| * Copyright 1998 Rob Riggs |
| * Copyright 2000-2002 TransGaming Technologies, Inc. |
| * Copyright 2004 Robert Reif |
| * |
| * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| #define NONAMELESSSTRUCT |
| #define NONAMELESSUNION |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winuser.h" |
| #include "winreg.h" |
| #include "mmsystem.h" |
| #include "winternl.h" |
| #include "mmddk.h" |
| #include "wine/debug.h" |
| #include "dsound.h" |
| #include "dsdriver.h" |
| #include "dsound_private.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(dsound); |
| |
| static ULONG WINAPI IDirectSound_IUnknown_AddRef(LPUNKNOWN iface); |
| static ULONG WINAPI IDirectSound_IDirectSound_AddRef(LPDIRECTSOUND iface); |
| static ULONG WINAPI IDirectSound8_IUnknown_AddRef(LPUNKNOWN iface); |
| static ULONG WINAPI IDirectSound8_IDirectSound_AddRef(LPDIRECTSOUND iface); |
| static ULONG WINAPI IDirectSound8_IDirectSound8_AddRef(LPDIRECTSOUND8 iface); |
| |
| const char * dumpCooperativeLevel(DWORD level) |
| { |
| static char unknown[32]; |
| #define LE(x) case x: return #x |
| switch (level) { |
| LE(DSSCL_NORMAL); |
| LE(DSSCL_PRIORITY); |
| LE(DSSCL_EXCLUSIVE); |
| LE(DSSCL_WRITEPRIMARY); |
| } |
| #undef LE |
| sprintf(unknown, "Unknown(%08lx)", level); |
| return unknown; |
| } |
| |
| static void _dump_DSCAPS(DWORD xmask) { |
| struct { |
| DWORD mask; |
| const char *name; |
| } flags[] = { |
| #define FE(x) { x, #x }, |
| FE(DSCAPS_PRIMARYMONO) |
| FE(DSCAPS_PRIMARYSTEREO) |
| FE(DSCAPS_PRIMARY8BIT) |
| FE(DSCAPS_PRIMARY16BIT) |
| FE(DSCAPS_CONTINUOUSRATE) |
| FE(DSCAPS_EMULDRIVER) |
| FE(DSCAPS_CERTIFIED) |
| FE(DSCAPS_SECONDARYMONO) |
| FE(DSCAPS_SECONDARYSTEREO) |
| FE(DSCAPS_SECONDARY8BIT) |
| FE(DSCAPS_SECONDARY16BIT) |
| #undef FE |
| }; |
| unsigned int i; |
| |
| for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++) |
| if ((flags[i].mask & xmask) == flags[i].mask) |
| DPRINTF("%s ",flags[i].name); |
| } |
| |
| static void _dump_DSBCAPS(DWORD xmask) { |
| struct { |
| DWORD mask; |
| const char *name; |
| } flags[] = { |
| #define FE(x) { x, #x }, |
| FE(DSBCAPS_PRIMARYBUFFER) |
| FE(DSBCAPS_STATIC) |
| FE(DSBCAPS_LOCHARDWARE) |
| FE(DSBCAPS_LOCSOFTWARE) |
| FE(DSBCAPS_CTRL3D) |
| FE(DSBCAPS_CTRLFREQUENCY) |
| FE(DSBCAPS_CTRLPAN) |
| FE(DSBCAPS_CTRLVOLUME) |
| FE(DSBCAPS_CTRLPOSITIONNOTIFY) |
| FE(DSBCAPS_STICKYFOCUS) |
| FE(DSBCAPS_GLOBALFOCUS) |
| FE(DSBCAPS_GETCURRENTPOSITION2) |
| FE(DSBCAPS_MUTE3DATMAXDISTANCE) |
| #undef FE |
| }; |
| unsigned int i; |
| |
| for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++) |
| if ((flags[i].mask & xmask) == flags[i].mask) |
| DPRINTF("%s ",flags[i].name); |
| } |
| |
| /******************************************************************************* |
| * IDirectSoundImpl_DirectSound |
| */ |
| static HRESULT DSOUND_QueryInterface( |
| LPDIRECTSOUND8 iface, |
| REFIID riid, |
| LPVOID * ppobj) |
| { |
| IDirectSoundImpl *This = (IDirectSoundImpl *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| |
| if (ppobj == NULL) { |
| WARN("invalid parameter\n"); |
| return E_INVALIDARG; |
| } |
| |
| if (IsEqualIID(riid, &IID_IUnknown)) { |
| if (!This->pUnknown) { |
| IDirectSound_IUnknown_Create(iface, &This->pUnknown); |
| if (!This->pUnknown) { |
| WARN("IDirectSound_IUnknown_Create() failed\n"); |
| *ppobj = NULL; |
| return E_NOINTERFACE; |
| } |
| } |
| IDirectSound_IUnknown_AddRef(This->pUnknown); |
| *ppobj = This->pUnknown; |
| return S_OK; |
| } else if (IsEqualIID(riid, &IID_IDirectSound)) { |
| if (!This->pDS) { |
| IDirectSound_IDirectSound_Create(iface, &This->pDS); |
| if (!This->pDS) { |
| WARN("IDirectSound_IDirectSound_Create() failed\n"); |
| *ppobj = NULL; |
| return E_NOINTERFACE; |
| } |
| } |
| IDirectSound_IDirectSound_AddRef(This->pDS); |
| *ppobj = This->pDS; |
| return S_OK; |
| } |
| |
| *ppobj = NULL; |
| WARN("Unknown IID %s\n",debugstr_guid(riid)); |
| return E_NOINTERFACE; |
| } |
| |
| static HRESULT DSOUND_QueryInterface8( |
| LPDIRECTSOUND8 iface, |
| REFIID riid, |
| LPVOID * ppobj) |
| { |
| IDirectSoundImpl *This = (IDirectSoundImpl *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| |
| if (ppobj == NULL) { |
| WARN("invalid parameter\n"); |
| return E_INVALIDARG; |
| } |
| |
| if (IsEqualIID(riid, &IID_IUnknown)) { |
| if (!This->pUnknown) { |
| IDirectSound8_IUnknown_Create(iface, &This->pUnknown); |
| if (!This->pUnknown) { |
| WARN("IDirectSound8_IUnknown_Create() failed\n"); |
| *ppobj = NULL; |
| return E_NOINTERFACE; |
| } |
| } |
| IDirectSound8_IUnknown_AddRef(This->pUnknown); |
| *ppobj = This->pUnknown; |
| return S_OK; |
| } else if (IsEqualIID(riid, &IID_IDirectSound)) { |
| if (!This->pDS) { |
| IDirectSound8_IDirectSound_Create(iface, &This->pDS); |
| if (!This->pDS) { |
| WARN("IDirectSound8_IDirectSound_Create() failed\n"); |
| *ppobj = NULL; |
| return E_NOINTERFACE; |
| } |
| } |
| IDirectSound8_IDirectSound_AddRef(This->pDS); |
| *ppobj = This->pDS; |
| return S_OK; |
| } else if (IsEqualIID(riid, &IID_IDirectSound8)) { |
| if (!This->pDS8) { |
| IDirectSound8_IDirectSound8_Create(iface, &This->pDS8); |
| if (!This->pDS8) { |
| WARN("IDirectSound8_IDirectSound8_Create() failed\n"); |
| *ppobj = NULL; |
| return E_NOINTERFACE; |
| } |
| } |
| IDirectSound8_IDirectSound8_AddRef(This->pDS8); |
| *ppobj = This->pDS8; |
| return S_OK; |
| } |
| |
| *ppobj = NULL; |
| WARN("Unknown IID %s\n",debugstr_guid(riid)); |
| return E_NOINTERFACE; |
| } |
| |
| static ULONG IDirectSoundImpl_AddRef( |
| LPDIRECTSOUND8 iface) |
| { |
| IDirectSoundImpl *This = (IDirectSoundImpl *)iface; |
| ULONG ref = InterlockedIncrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref - 1); |
| return ref; |
| } |
| |
| static ULONG IDirectSoundImpl_Release( |
| LPDIRECTSOUND8 iface) |
| { |
| IDirectSoundImpl *This = (IDirectSoundImpl *)iface; |
| ULONG ref = InterlockedDecrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref + 1); |
| |
| if (!ref) { |
| if (This->device) |
| DirectSoundDevice_Release(This->device); |
| HeapFree(GetProcessHeap(),0,This); |
| TRACE("(%p) released\n", This); |
| } |
| return ref; |
| } |
| |
| HRESULT IDirectSoundImpl_Create( |
| LPDIRECTSOUND8 * ppDS) |
| { |
| IDirectSoundImpl* pDS; |
| TRACE("(%p)\n",ppDS); |
| |
| /* Allocate memory */ |
| pDS = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundImpl)); |
| if (pDS == NULL) { |
| WARN("out of memory\n"); |
| *ppDS = NULL; |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| pDS->ref = 0; |
| pDS->device = NULL; |
| |
| *ppDS = (LPDIRECTSOUND8)pDS; |
| |
| return DS_OK; |
| } |
| |
| /******************************************************************************* |
| * IDirectSound_IUnknown |
| */ |
| static HRESULT WINAPI IDirectSound_IUnknown_QueryInterface( |
| LPUNKNOWN iface, |
| REFIID riid, |
| LPVOID * ppobj) |
| { |
| IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| return DSOUND_QueryInterface(This->pds, riid, ppobj); |
| } |
| |
| static ULONG WINAPI IDirectSound_IUnknown_AddRef( |
| LPUNKNOWN iface) |
| { |
| IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface; |
| ULONG ref = InterlockedIncrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref - 1); |
| return ref; |
| } |
| |
| static ULONG WINAPI IDirectSound_IUnknown_Release( |
| LPUNKNOWN iface) |
| { |
| IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface; |
| ULONG ref = InterlockedDecrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref + 1); |
| if (!ref) { |
| IDirectSoundImpl_Release(This->pds); |
| HeapFree(GetProcessHeap(), 0, This); |
| TRACE("(%p) released\n", This); |
| } |
| return ref; |
| } |
| |
| static const IUnknownVtbl DirectSound_Unknown_Vtbl = |
| { |
| IDirectSound_IUnknown_QueryInterface, |
| IDirectSound_IUnknown_AddRef, |
| IDirectSound_IUnknown_Release |
| }; |
| |
| HRESULT IDirectSound_IUnknown_Create( |
| LPDIRECTSOUND8 pds, |
| LPUNKNOWN * ppunk) |
| { |
| IDirectSound_IUnknown * pdsunk; |
| TRACE("(%p,%p)\n",pds,ppunk); |
| |
| if (ppunk == NULL) { |
| ERR("invalid parameter: ppunk == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (pds == NULL) { |
| ERR("invalid parameter: pds == NULL\n"); |
| *ppunk = NULL; |
| return DSERR_INVALIDPARAM; |
| } |
| |
| pdsunk = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsunk)); |
| if (pdsunk == NULL) { |
| WARN("out of memory\n"); |
| *ppunk = NULL; |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| pdsunk->lpVtbl = &DirectSound_Unknown_Vtbl; |
| pdsunk->ref = 0; |
| pdsunk->pds = pds; |
| |
| IDirectSoundImpl_AddRef(pds); |
| *ppunk = (LPUNKNOWN)pdsunk; |
| |
| return DS_OK; |
| } |
| |
| /******************************************************************************* |
| * IDirectSound_IDirectSound |
| */ |
| static HRESULT WINAPI IDirectSound_IDirectSound_QueryInterface( |
| LPDIRECTSOUND iface, |
| REFIID riid, |
| LPVOID * ppobj) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| return DSOUND_QueryInterface(This->pds, riid, ppobj); |
| } |
| |
| static ULONG WINAPI IDirectSound_IDirectSound_AddRef( |
| LPDIRECTSOUND iface) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| ULONG ref = InterlockedIncrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref - 1); |
| return ref; |
| } |
| |
| static ULONG WINAPI IDirectSound_IDirectSound_Release( |
| LPDIRECTSOUND iface) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| ULONG ref = InterlockedDecrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref + 1); |
| if (!ref) { |
| IDirectSoundImpl_Release(This->pds); |
| HeapFree(GetProcessHeap(), 0, This); |
| TRACE("(%p) released\n", This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_CreateSoundBuffer( |
| LPDIRECTSOUND iface, |
| LPCDSBUFFERDESC dsbd, |
| LPLPDIRECTSOUNDBUFFER ppdsb, |
| LPUNKNOWN lpunk) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk); |
| return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,FALSE); |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_GetCaps( |
| LPDIRECTSOUND iface, |
| LPDSCAPS lpDSCaps) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p,%p)\n",This,lpDSCaps); |
| return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps); |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_DuplicateSoundBuffer( |
| LPDIRECTSOUND iface, |
| LPDIRECTSOUNDBUFFER psb, |
| LPLPDIRECTSOUNDBUFFER ppdsb) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p,%p,%p)\n",This,psb,ppdsb); |
| return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb); |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_SetCooperativeLevel( |
| LPDIRECTSOUND iface, |
| HWND hwnd, |
| DWORD level) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level)); |
| return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level); |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_Compact( |
| LPDIRECTSOUND iface) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p)\n", This); |
| return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device); |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_GetSpeakerConfig( |
| LPDIRECTSOUND iface, |
| LPDWORD lpdwSpeakerConfig) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p, %p)\n", This, lpdwSpeakerConfig); |
| return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig); |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_SetSpeakerConfig( |
| LPDIRECTSOUND iface, |
| DWORD config) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p,0x%08lx)\n",This,config); |
| return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config); |
| } |
| |
| static HRESULT WINAPI IDirectSound_IDirectSound_Initialize( |
| LPDIRECTSOUND iface, |
| LPCGUID lpcGuid) |
| { |
| IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface; |
| TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid)); |
| return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid); |
| } |
| |
| static const IDirectSoundVtbl DirectSound_DirectSound_Vtbl = |
| { |
| IDirectSound_IDirectSound_QueryInterface, |
| IDirectSound_IDirectSound_AddRef, |
| IDirectSound_IDirectSound_Release, |
| IDirectSound_IDirectSound_CreateSoundBuffer, |
| IDirectSound_IDirectSound_GetCaps, |
| IDirectSound_IDirectSound_DuplicateSoundBuffer, |
| IDirectSound_IDirectSound_SetCooperativeLevel, |
| IDirectSound_IDirectSound_Compact, |
| IDirectSound_IDirectSound_GetSpeakerConfig, |
| IDirectSound_IDirectSound_SetSpeakerConfig, |
| IDirectSound_IDirectSound_Initialize |
| }; |
| |
| HRESULT IDirectSound_IDirectSound_Create( |
| LPDIRECTSOUND8 pds, |
| LPDIRECTSOUND * ppds) |
| { |
| IDirectSound_IDirectSound * pdsds; |
| TRACE("(%p,%p)\n",pds,ppds); |
| |
| if (ppds == NULL) { |
| ERR("invalid parameter: ppds == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (pds == NULL) { |
| ERR("invalid parameter: pds == NULL\n"); |
| *ppds = NULL; |
| return DSERR_INVALIDPARAM; |
| } |
| |
| pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds)); |
| if (pdsds == NULL) { |
| WARN("out of memory\n"); |
| *ppds = NULL; |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| pdsds->lpVtbl = &DirectSound_DirectSound_Vtbl; |
| pdsds->ref = 0; |
| pdsds->pds = pds; |
| |
| IDirectSoundImpl_AddRef(pds); |
| *ppds = (LPDIRECTSOUND)pdsds; |
| |
| return DS_OK; |
| } |
| |
| /******************************************************************************* |
| * IDirectSound8_IUnknown |
| */ |
| static HRESULT WINAPI IDirectSound8_IUnknown_QueryInterface( |
| LPUNKNOWN iface, |
| REFIID riid, |
| LPVOID * ppobj) |
| { |
| IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| return DSOUND_QueryInterface8(This->pds, riid, ppobj); |
| } |
| |
| static ULONG WINAPI IDirectSound8_IUnknown_AddRef( |
| LPUNKNOWN iface) |
| { |
| IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface; |
| ULONG ref = InterlockedIncrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref - 1); |
| return ref; |
| } |
| |
| static ULONG WINAPI IDirectSound8_IUnknown_Release( |
| LPUNKNOWN iface) |
| { |
| IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface; |
| ULONG ref = InterlockedDecrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref + 1); |
| if (!ref) { |
| IDirectSoundImpl_Release(This->pds); |
| HeapFree(GetProcessHeap(), 0, This); |
| TRACE("(%p) released\n", This); |
| } |
| return ref; |
| } |
| |
| static const IUnknownVtbl DirectSound8_Unknown_Vtbl = |
| { |
| IDirectSound8_IUnknown_QueryInterface, |
| IDirectSound8_IUnknown_AddRef, |
| IDirectSound8_IUnknown_Release |
| }; |
| |
| HRESULT IDirectSound8_IUnknown_Create( |
| LPDIRECTSOUND8 pds, |
| LPUNKNOWN * ppunk) |
| { |
| IDirectSound8_IUnknown * pdsunk; |
| TRACE("(%p,%p)\n",pds,ppunk); |
| |
| if (ppunk == NULL) { |
| ERR("invalid parameter: ppunk == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (pds == NULL) { |
| ERR("invalid parameter: pds == NULL\n"); |
| *ppunk = NULL; |
| return DSERR_INVALIDPARAM; |
| } |
| |
| pdsunk = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsunk)); |
| if (pdsunk == NULL) { |
| WARN("out of memory\n"); |
| *ppunk = NULL; |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| pdsunk->lpVtbl = &DirectSound8_Unknown_Vtbl; |
| pdsunk->ref = 0; |
| pdsunk->pds = pds; |
| |
| IDirectSoundImpl_AddRef(pds); |
| *ppunk = (LPUNKNOWN)pdsunk; |
| |
| return DS_OK; |
| } |
| |
| /******************************************************************************* |
| * IDirectSound8_IDirectSound |
| */ |
| static HRESULT WINAPI IDirectSound8_IDirectSound_QueryInterface( |
| LPDIRECTSOUND iface, |
| REFIID riid, |
| LPVOID * ppobj) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| return DSOUND_QueryInterface8(This->pds, riid, ppobj); |
| } |
| |
| static ULONG WINAPI IDirectSound8_IDirectSound_AddRef( |
| LPDIRECTSOUND iface) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| ULONG ref = InterlockedIncrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref - 1); |
| return ref; |
| } |
| |
| static ULONG WINAPI IDirectSound8_IDirectSound_Release( |
| LPDIRECTSOUND iface) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| ULONG ref = InterlockedDecrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref + 1); |
| if (!ref) { |
| IDirectSoundImpl_Release(This->pds); |
| HeapFree(GetProcessHeap(), 0, This); |
| TRACE("(%p) released\n", This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_CreateSoundBuffer( |
| LPDIRECTSOUND iface, |
| LPCDSBUFFERDESC dsbd, |
| LPLPDIRECTSOUNDBUFFER ppdsb, |
| LPUNKNOWN lpunk) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk); |
| return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,TRUE); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_GetCaps( |
| LPDIRECTSOUND iface, |
| LPDSCAPS lpDSCaps) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p,%p)\n",This,lpDSCaps); |
| return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_DuplicateSoundBuffer( |
| LPDIRECTSOUND iface, |
| LPDIRECTSOUNDBUFFER psb, |
| LPLPDIRECTSOUNDBUFFER ppdsb) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p,%p,%p)\n",This,psb,ppdsb); |
| return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_SetCooperativeLevel( |
| LPDIRECTSOUND iface, |
| HWND hwnd, |
| DWORD level) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level)); |
| return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_Compact( |
| LPDIRECTSOUND iface) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p)\n", This); |
| return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_GetSpeakerConfig( |
| LPDIRECTSOUND iface, |
| LPDWORD lpdwSpeakerConfig) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p, %p)\n", This, lpdwSpeakerConfig); |
| return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_SetSpeakerConfig( |
| LPDIRECTSOUND iface, |
| DWORD config) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p,0x%08lx)\n",This,config); |
| return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound_Initialize( |
| LPDIRECTSOUND iface, |
| LPCGUID lpcGuid) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid)); |
| return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid); |
| } |
| |
| static const IDirectSoundVtbl DirectSound8_DirectSound_Vtbl = |
| { |
| IDirectSound8_IDirectSound_QueryInterface, |
| IDirectSound8_IDirectSound_AddRef, |
| IDirectSound8_IDirectSound_Release, |
| IDirectSound8_IDirectSound_CreateSoundBuffer, |
| IDirectSound8_IDirectSound_GetCaps, |
| IDirectSound8_IDirectSound_DuplicateSoundBuffer, |
| IDirectSound8_IDirectSound_SetCooperativeLevel, |
| IDirectSound8_IDirectSound_Compact, |
| IDirectSound8_IDirectSound_GetSpeakerConfig, |
| IDirectSound8_IDirectSound_SetSpeakerConfig, |
| IDirectSound8_IDirectSound_Initialize |
| }; |
| |
| HRESULT IDirectSound8_IDirectSound_Create( |
| LPDIRECTSOUND8 pds, |
| LPDIRECTSOUND * ppds) |
| { |
| IDirectSound8_IDirectSound * pdsds; |
| TRACE("(%p,%p)\n",pds,ppds); |
| |
| if (ppds == NULL) { |
| ERR("invalid parameter: ppds == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (pds == NULL) { |
| ERR("invalid parameter: pds == NULL\n"); |
| *ppds = NULL; |
| return DSERR_INVALIDPARAM; |
| } |
| |
| pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds)); |
| if (pdsds == NULL) { |
| WARN("out of memory\n"); |
| *ppds = NULL; |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| pdsds->lpVtbl = &DirectSound8_DirectSound_Vtbl; |
| pdsds->ref = 0; |
| pdsds->pds = pds; |
| |
| IDirectSoundImpl_AddRef(pds); |
| *ppds = (LPDIRECTSOUND)pdsds; |
| |
| return DS_OK; |
| } |
| |
| /******************************************************************************* |
| * IDirectSound8_IDirectSound8 |
| */ |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_QueryInterface( |
| LPDIRECTSOUND8 iface, |
| REFIID riid, |
| LPVOID * ppobj) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| return DSOUND_QueryInterface8(This->pds, riid, ppobj); |
| } |
| |
| static ULONG WINAPI IDirectSound8_IDirectSound8_AddRef( |
| LPDIRECTSOUND8 iface) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| ULONG ref = InterlockedIncrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref - 1); |
| return ref; |
| } |
| |
| static ULONG WINAPI IDirectSound8_IDirectSound8_Release( |
| LPDIRECTSOUND8 iface) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| ULONG ref = InterlockedDecrement(&(This->ref)); |
| TRACE("(%p) ref was %ld\n", This, ref + 1); |
| if (!ref) { |
| IDirectSoundImpl_Release(This->pds); |
| HeapFree(GetProcessHeap(), 0, This); |
| TRACE("(%p) released\n", This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_CreateSoundBuffer( |
| LPDIRECTSOUND8 iface, |
| LPCDSBUFFERDESC dsbd, |
| LPLPDIRECTSOUNDBUFFER ppdsb, |
| LPUNKNOWN lpunk) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk); |
| return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,TRUE); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_GetCaps( |
| LPDIRECTSOUND8 iface, |
| LPDSCAPS lpDSCaps) |
| { |
| IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface; |
| TRACE("(%p,%p)\n",This,lpDSCaps); |
| return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_DuplicateSoundBuffer( |
| LPDIRECTSOUND8 iface, |
| LPDIRECTSOUNDBUFFER psb, |
| LPLPDIRECTSOUNDBUFFER ppdsb) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p,%p,%p)\n",This,psb,ppdsb); |
| return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_SetCooperativeLevel( |
| LPDIRECTSOUND8 iface, |
| HWND hwnd, |
| DWORD level) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level)); |
| return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_Compact( |
| LPDIRECTSOUND8 iface) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p)\n", This); |
| return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_GetSpeakerConfig( |
| LPDIRECTSOUND8 iface, |
| LPDWORD lpdwSpeakerConfig) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p, %p)\n", This, lpdwSpeakerConfig); |
| return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_SetSpeakerConfig( |
| LPDIRECTSOUND8 iface, |
| DWORD config) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p,0x%08lx)\n",This,config); |
| return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_Initialize( |
| LPDIRECTSOUND8 iface, |
| LPCGUID lpcGuid) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid)); |
| return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid); |
| } |
| |
| static HRESULT WINAPI IDirectSound8_IDirectSound8_VerifyCertification( |
| LPDIRECTSOUND8 iface, |
| LPDWORD pdwCertified) |
| { |
| IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface; |
| TRACE("(%p, %p)\n", This, pdwCertified); |
| return DirectSoundDevice_VerifyCertification(((IDirectSoundImpl *)This->pds)->device,pdwCertified); |
| } |
| |
| static const IDirectSound8Vtbl DirectSound8_DirectSound8_Vtbl = |
| { |
| IDirectSound8_IDirectSound8_QueryInterface, |
| IDirectSound8_IDirectSound8_AddRef, |
| IDirectSound8_IDirectSound8_Release, |
| IDirectSound8_IDirectSound8_CreateSoundBuffer, |
| IDirectSound8_IDirectSound8_GetCaps, |
| IDirectSound8_IDirectSound8_DuplicateSoundBuffer, |
| IDirectSound8_IDirectSound8_SetCooperativeLevel, |
| IDirectSound8_IDirectSound8_Compact, |
| IDirectSound8_IDirectSound8_GetSpeakerConfig, |
| IDirectSound8_IDirectSound8_SetSpeakerConfig, |
| IDirectSound8_IDirectSound8_Initialize, |
| IDirectSound8_IDirectSound8_VerifyCertification |
| }; |
| |
| HRESULT IDirectSound8_IDirectSound8_Create( |
| LPDIRECTSOUND8 pds, |
| LPDIRECTSOUND8 * ppds) |
| { |
| IDirectSound8_IDirectSound8 * pdsds; |
| TRACE("(%p,%p)\n",pds,ppds); |
| |
| if (ppds == NULL) { |
| ERR("invalid parameter: ppds == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (pds == NULL) { |
| ERR("invalid parameter: pds == NULL\n"); |
| *ppds = NULL; |
| return DSERR_INVALIDPARAM; |
| } |
| |
| pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds)); |
| if (pdsds == NULL) { |
| WARN("out of memory\n"); |
| *ppds = NULL; |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| pdsds->lpVtbl = &DirectSound8_DirectSound8_Vtbl; |
| pdsds->ref = 0; |
| pdsds->pds = pds; |
| |
| IDirectSoundImpl_AddRef(pds); |
| *ppds = (LPDIRECTSOUND8)pdsds; |
| |
| return DS_OK; |
| } |
| |
| HRESULT DSOUND_Create( |
| LPDIRECTSOUND *ppDS, |
| IUnknown *pUnkOuter) |
| { |
| LPDIRECTSOUND8 pDS; |
| HRESULT hr; |
| TRACE("(%p,%p)\n",ppDS,pUnkOuter); |
| |
| /* Get dsound configuration */ |
| setup_dsound_options(); |
| |
| hr = IDirectSoundImpl_Create(&pDS); |
| if (hr == DS_OK) { |
| hr = IDirectSound_IDirectSound_Create(pDS, ppDS); |
| if (*ppDS) |
| IDirectSound_IDirectSound_AddRef(*ppDS); |
| else { |
| WARN("IDirectSound_IDirectSound_Create failed\n"); |
| IDirectSound8_Release(pDS); |
| } |
| } else { |
| WARN("IDirectSoundImpl_Create failed\n"); |
| *ppDS = 0; |
| } |
| |
| return hr; |
| } |
| |
| /******************************************************************************* |
| * DirectSoundCreate (DSOUND.1) |
| * |
| * Creates and initializes a DirectSound interface. |
| * |
| * PARAMS |
| * lpcGUID [I] Address of the GUID that identifies the sound device. |
| * ppDS [O] Address of a variable to receive the interface pointer. |
| * pUnkOuter [I] Must be NULL. |
| * |
| * RETURNS |
| * Success: DS_OK |
| * Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION, |
| * DSERR_NODRIVER, DSERR_OUTOFMEMORY |
| */ |
| HRESULT WINAPI DirectSoundCreate( |
| LPCGUID lpcGUID, |
| LPDIRECTSOUND *ppDS, |
| IUnknown *pUnkOuter) |
| { |
| HRESULT hr; |
| LPDIRECTSOUND pDS; |
| |
| TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter); |
| |
| if (ppDS == NULL) { |
| WARN("invalid parameter: ppDS == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (pUnkOuter != NULL) { |
| WARN("invalid parameter: pUnkOuter != NULL\n"); |
| *ppDS = 0; |
| return DSERR_INVALIDPARAM; |
| } |
| |
| hr = DSOUND_Create(&pDS, pUnkOuter); |
| if (hr == DS_OK) { |
| hr = IDirectSound_Initialize(pDS, lpcGUID); |
| if (hr != DS_OK) { |
| if (hr != DSERR_ALREADYINITIALIZED) { |
| IDirectSound_Release(pDS); |
| pDS = 0; |
| } else |
| hr = DS_OK; |
| } |
| } |
| |
| *ppDS = pDS; |
| |
| return hr; |
| } |
| |
| HRESULT DSOUND_Create8( |
| LPDIRECTSOUND8 *ppDS, |
| IUnknown *pUnkOuter) |
| { |
| LPDIRECTSOUND8 pDS; |
| HRESULT hr; |
| TRACE("(%p,%p)\n",ppDS,pUnkOuter); |
| |
| /* Get dsound configuration */ |
| setup_dsound_options(); |
| |
| hr = IDirectSoundImpl_Create(&pDS); |
| if (hr == DS_OK) { |
| hr = IDirectSound8_IDirectSound8_Create(pDS, ppDS); |
| if (*ppDS) |
| IDirectSound8_IDirectSound8_AddRef(*ppDS); |
| else { |
| WARN("IDirectSound8_IDirectSound8_Create failed\n"); |
| IDirectSound8_Release(pDS); |
| } |
| } else { |
| WARN("IDirectSoundImpl_Create failed\n"); |
| *ppDS = 0; |
| } |
| |
| return hr; |
| } |
| |
| /******************************************************************************* |
| * DirectSoundCreate8 (DSOUND.11) |
| * |
| * Creates and initializes a DirectSound8 interface. |
| * |
| * PARAMS |
| * lpcGUID [I] Address of the GUID that identifies the sound device. |
| * ppDS [O] Address of a variable to receive the interface pointer. |
| * pUnkOuter [I] Must be NULL. |
| * |
| * RETURNS |
| * Success: DS_OK |
| * Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION, |
| * DSERR_NODRIVER, DSERR_OUTOFMEMORY |
| */ |
| HRESULT WINAPI DirectSoundCreate8( |
| LPCGUID lpcGUID, |
| LPDIRECTSOUND8 *ppDS, |
| IUnknown *pUnkOuter) |
| { |
| HRESULT hr; |
| LPDIRECTSOUND8 pDS; |
| |
| TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter); |
| |
| if (ppDS == NULL) { |
| WARN("invalid parameter: ppDS == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (pUnkOuter != NULL) { |
| WARN("invalid parameter: pUnkOuter != NULL\n"); |
| *ppDS = 0; |
| return DSERR_INVALIDPARAM; |
| } |
| |
| hr = DSOUND_Create8(&pDS, pUnkOuter); |
| if (hr == DS_OK) { |
| hr = IDirectSound8_Initialize(pDS, lpcGUID); |
| if (hr != DS_OK) { |
| if (hr != DSERR_ALREADYINITIALIZED) { |
| IDirectSound8_Release(pDS); |
| pDS = 0; |
| } else |
| hr = DS_OK; |
| } |
| } |
| |
| *ppDS = pDS; |
| |
| return hr; |
| } |
| |
| /******************************************************************************* |
| * DirectSoundDevice |
| */ |
| HRESULT DirectSoundDevice_Create(DirectSoundDevice ** ppDevice) |
| { |
| DirectSoundDevice * device; |
| TRACE("(%p)\n", ppDevice); |
| |
| /* Allocate memory */ |
| device = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DirectSoundDevice)); |
| if (device == NULL) { |
| WARN("out of memory\n"); |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| device->ref = 1; |
| device->driver = NULL; |
| device->priolevel = DSSCL_NORMAL; |
| device->fraglen = 0; |
| device->hwbuf = NULL; |
| device->buffer = NULL; |
| device->buflen = 0; |
| device->writelead = 0; |
| device->state = STATE_STOPPED; |
| device->nrofbuffers = 0; |
| device->buffers = NULL; |
| device->primary = NULL; |
| device->speaker_config = DSSPEAKER_STEREO | (DSSPEAKER_GEOMETRY_NARROW << 16); |
| device->tmp_buffer = NULL; |
| device->tmp_buffer_len = 0; |
| |
| /* 3D listener initial parameters */ |
| device->listener = NULL; |
| device->ds3dl.dwSize = sizeof(DS3DLISTENER); |
| device->ds3dl.vPosition.x = 0.0; |
| device->ds3dl.vPosition.y = 0.0; |
| device->ds3dl.vPosition.z = 0.0; |
| device->ds3dl.vVelocity.x = 0.0; |
| device->ds3dl.vVelocity.y = 0.0; |
| device->ds3dl.vVelocity.z = 0.0; |
| device->ds3dl.vOrientFront.x = 0.0; |
| device->ds3dl.vOrientFront.y = 0.0; |
| device->ds3dl.vOrientFront.z = 1.0; |
| device->ds3dl.vOrientTop.x = 0.0; |
| device->ds3dl.vOrientTop.y = 1.0; |
| device->ds3dl.vOrientTop.z = 0.0; |
| device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR; |
| device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR; |
| device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR; |
| |
| device->prebuf = ds_snd_queue_max; |
| device->guid = GUID_NULL; |
| |
| /* Set default wave format (may need it for waveOutOpen) */ |
| device->pwfx = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(WAVEFORMATEX)); |
| if (device->pwfx == NULL) { |
| WARN("out of memory\n"); |
| HeapFree(GetProcessHeap(),0,device); |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| /* We rely on the sound driver to return the actual sound format of |
| * the device if it does not support 22050x8x2 and is given the |
| * WAVE_DIRECTSOUND flag. |
| */ |
| device->pwfx->wFormatTag = WAVE_FORMAT_PCM; |
| device->pwfx->nSamplesPerSec = 22050; |
| device->pwfx->wBitsPerSample = 8; |
| device->pwfx->nChannels = 2; |
| device->pwfx->nBlockAlign = device->pwfx->wBitsPerSample * device->pwfx->nChannels / 8; |
| device->pwfx->nAvgBytesPerSec = device->pwfx->nSamplesPerSec * device->pwfx->nBlockAlign; |
| device->pwfx->cbSize = 0; |
| |
| InitializeCriticalSection(&(device->mixlock)); |
| device->mixlock.DebugInfo->Spare[0] = (DWORD_PTR)"DSOUND_mixlock"; |
| |
| RtlInitializeResource(&(device->buffer_list_lock)); |
| |
| *ppDevice = device; |
| |
| return DS_OK; |
| } |
| |
| ULONG DirectSoundDevice_AddRef(DirectSoundDevice * device) |
| { |
| ULONG ref = InterlockedIncrement(&(device->ref)); |
| TRACE("(%p) ref was %ld\n", device, ref - 1); |
| return ref; |
| } |
| |
| ULONG DirectSoundDevice_Release(DirectSoundDevice * device) |
| { |
| HRESULT hr; |
| ULONG ref = InterlockedDecrement(&(device->ref)); |
| TRACE("(%p) ref was %lu\n", device, ref + 1); |
| if (!ref) { |
| int i; |
| timeKillEvent(device->timerID); |
| timeEndPeriod(DS_TIME_RES); |
| /* wait for timer to expire */ |
| Sleep(DS_TIME_RES+1); |
| |
| /* The sleep above should have allowed the timer process to expire |
| * but try to grab the lock just in case. Can't hold lock because |
| * IDirectSoundBufferImpl_Destroy also grabs the lock */ |
| RtlAcquireResourceShared(&(device->buffer_list_lock), TRUE); |
| RtlReleaseResource(&(device->buffer_list_lock)); |
| |
| /* It is allowed to release this object even when buffers are playing */ |
| if (device->buffers) { |
| WARN("%d secondary buffers not released\n", device->nrofbuffers); |
| for( i=0;i<device->nrofbuffers;i++) |
| IDirectSoundBufferImpl_Destroy(device->buffers[i]); |
| } |
| |
| if (device->primary) { |
| WARN("primary buffer not released\n"); |
| IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)device->primary); |
| } |
| |
| hr = DSOUND_PrimaryDestroy(device); |
| if (hr != DS_OK) |
| WARN("DSOUND_PrimaryDestroy failed\n"); |
| |
| if (device->driver) |
| IDsDriver_Close(device->driver); |
| |
| if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN) |
| waveOutClose(device->hwo); |
| |
| if (device->driver) |
| IDsDriver_Release(device->driver); |
| |
| DSOUND_renderer[device->drvdesc.dnDevNode] = NULL; |
| |
| HeapFree(GetProcessHeap(),0,device->tmp_buffer); |
| HeapFree(GetProcessHeap(),0,device->buffer); |
| RtlDeleteResource(&device->buffer_list_lock); |
| device->mixlock.DebugInfo->Spare[0] = 0; |
| DeleteCriticalSection(&device->mixlock); |
| HeapFree(GetProcessHeap(),0,device); |
| TRACE("(%p) released\n", device); |
| } |
| 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 = %ld < %d\n", |
| lpDSCaps->dwSize, sizeof(*lpDSCaps)); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| lpDSCaps->dwFlags = device->drvcaps.dwFlags; |
| if (TRACE_ON(dsound)) { |
| TRACE("(flags=0x%08lx:\n",lpDSCaps->dwFlags); |
| _dump_DSCAPS(lpDSCaps->dwFlags); |
| DPRINTF(")\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; |
| |
| /* driver doesn't have these */ |
| lpDSCaps->dwUnlockTransferRateHwBuffers = 4096; /* But we have none... */ |
| lpDSCaps->dwPlayCpuOverheadSwBuffers = 1; /* 1% */ |
| |
| return DS_OK; |
| } |
| |
| HRESULT DirectSoundDevice_Initialize(DirectSoundDevice ** ppDevice, LPCGUID lpcGUID) |
| { |
| HRESULT hr = DS_OK; |
| unsigned wod, wodn; |
| BOOLEAN found = FALSE; |
| GUID devGUID; |
| DirectSoundDevice * device = *ppDevice; |
| TRACE("(%p,%s)\n",ppDevice,debugstr_guid(lpcGUID)); |
| |
| if (*ppDevice != NULL) { |
| WARN("already initialized\n"); |
| return DSERR_ALREADYINITIALIZED; |
| } |
| |
| /* Default device? */ |
| if (!lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL)) |
| lpcGUID = &DSDEVID_DefaultPlayback; |
| |
| if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) { |
| WARN("invalid parameter: lpcGUID\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| /* Enumerate WINMM audio devices and find the one we want */ |
| wodn = waveOutGetNumDevs(); |
| if (!wodn) { |
| WARN("no driver\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| for (wod=0; wod<wodn; wod++) { |
| if (IsEqualGUID( &devGUID, &DSOUND_renderer_guids[wod])) { |
| found = TRUE; |
| break; |
| } |
| } |
| |
| if (found == FALSE) { |
| WARN("No device found matching given ID!\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| if (DSOUND_renderer[wod]) { |
| if (IsEqualGUID(&devGUID, &DSOUND_renderer[wod]->guid)) { |
| device = DSOUND_renderer[wod]; |
| DirectSoundDevice_AddRef(device); |
| *ppDevice = device; |
| return DS_OK; |
| } else { |
| ERR("device GUID doesn't match\n"); |
| hr = DSERR_GENERIC; |
| return hr; |
| } |
| } else { |
| hr = DirectSoundDevice_Create(&device); |
| if (hr != DS_OK) { |
| WARN("DirectSoundDevice_Create failed\n"); |
| return hr; |
| } |
| } |
| |
| *ppDevice = device; |
| device->guid = devGUID; |
| |
| /* DRV_QUERYDSOUNDIFACE is a "Wine extension" to get the DSound interface */ |
| waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&device->driver, 0); |
| |
| /* Disable the direct sound driver to force emulation if requested. */ |
| if (ds_hw_accel == DS_HW_ACCEL_EMULATION) |
| device->driver = NULL; |
| |
| /* Get driver description */ |
| if (device->driver) { |
| hr = IDsDriver_GetDriverDesc(device->driver,&(device->drvdesc)); |
| if (hr != DS_OK) { |
| WARN("IDsDriver_GetDriverDesc failed\n"); |
| return hr; |
| } |
| } else { |
| /* if no DirectSound interface available, use WINMM API instead */ |
| device->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT; |
| } |
| |
| device->drvdesc.dnDevNode = wod; |
| |
| /* If the driver requests being opened through MMSYSTEM |
| * (which is recommended by the DDK), it is supposed to happen |
| * before the DirectSound interface is opened */ |
| if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN) |
| { |
| DWORD flags = CALLBACK_FUNCTION; |
| |
| /* disable direct sound if requested */ |
| if (ds_hw_accel != DS_HW_ACCEL_EMULATION) |
| flags |= WAVE_DIRECTSOUND; |
| |
| hr = mmErr(waveOutOpen(&(device->hwo), |
| device->drvdesc.dnDevNode, device->pwfx, |
| (DWORD_PTR)DSOUND_callback, (DWORD)device, |
| flags)); |
| if (hr != DS_OK) { |
| WARN("waveOutOpen failed\n"); |
| return hr; |
| } |
| } |
| |
| if (device->driver) { |
| hr = IDsDriver_Open(device->driver); |
| if (hr != DS_OK) { |
| WARN("IDsDriver_Open failed\n"); |
| return hr; |
| } |
| |
| /* the driver is now open, so it's now allowed to call GetCaps */ |
| hr = IDsDriver_GetCaps(device->driver,&(device->drvcaps)); |
| if (hr != DS_OK) { |
| WARN("IDsDriver_GetCaps failed\n"); |
| return hr; |
| } |
| } else { |
| WAVEOUTCAPSA woc; |
| hr = mmErr(waveOutGetDevCapsA(device->drvdesc.dnDevNode, &woc, sizeof(woc))); |
| if (hr != DS_OK) { |
| WARN("waveOutGetDevCaps failed\n"); |
| return hr; |
| } |
| ZeroMemory(&device->drvcaps, sizeof(device->drvcaps)); |
| if ((woc.dwFormats & WAVE_FORMAT_1M08) || |
| (woc.dwFormats & WAVE_FORMAT_2M08) || |
| (woc.dwFormats & WAVE_FORMAT_4M08) || |
| (woc.dwFormats & WAVE_FORMAT_48M08) || |
| (woc.dwFormats & WAVE_FORMAT_96M08)) { |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT; |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO; |
| } |
| if ((woc.dwFormats & WAVE_FORMAT_1M16) || |
| (woc.dwFormats & WAVE_FORMAT_2M16) || |
| (woc.dwFormats & WAVE_FORMAT_4M16) || |
| (woc.dwFormats & WAVE_FORMAT_48M16) || |
| (woc.dwFormats & WAVE_FORMAT_96M16)) { |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT; |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO; |
| } |
| if ((woc.dwFormats & WAVE_FORMAT_1S08) || |
| (woc.dwFormats & WAVE_FORMAT_2S08) || |
| (woc.dwFormats & WAVE_FORMAT_4S08) || |
| (woc.dwFormats & WAVE_FORMAT_48S08) || |
| (woc.dwFormats & WAVE_FORMAT_96S08)) { |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT; |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO; |
| } |
| if ((woc.dwFormats & WAVE_FORMAT_1S16) || |
| (woc.dwFormats & WAVE_FORMAT_2S16) || |
| (woc.dwFormats & WAVE_FORMAT_4S16) || |
| (woc.dwFormats & WAVE_FORMAT_48S16) || |
| (woc.dwFormats & WAVE_FORMAT_96S16)) { |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT; |
| device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO; |
| } |
| if (ds_emuldriver) |
| device->drvcaps.dwFlags |= DSCAPS_EMULDRIVER; |
| device->drvcaps.dwMinSecondarySampleRate = DSBFREQUENCY_MIN; |
| device->drvcaps.dwMaxSecondarySampleRate = DSBFREQUENCY_MAX; |
| device->drvcaps.dwPrimaryBuffers = 1; |
| } |
| |
| hr = DSOUND_PrimaryCreate(device); |
| if (hr == DS_OK) { |
| DSOUND_renderer[device->drvdesc.dnDevNode] = device; |
| timeBeginPeriod(DS_TIME_RES); |
| DSOUND_renderer[device->drvdesc.dnDevNode]->timerID = timeSetEvent(DS_TIME_DEL, DS_TIME_RES, DSOUND_timer, |
| (DWORD_PTR)DSOUND_renderer[device->drvdesc.dnDevNode], TIME_PERIODIC | TIME_CALLBACK_FUNCTION); |
| } else { |
| WARN("DSOUND_PrimaryCreate failed\n"); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT DirectSoundDevice_CreateSoundBuffer( |
| DirectSoundDevice * device, |
| LPCDSBUFFERDESC dsbd, |
| LPLPDIRECTSOUNDBUFFER ppdsb, |
| LPUNKNOWN lpunk, |
| BOOL from8) |
| { |
| HRESULT hres = DS_OK; |
| TRACE("(%p,%p,%p,%p)\n",device,dsbd,ppdsb,lpunk); |
| |
| if (device == NULL) { |
| WARN("not initialized\n"); |
| return DSERR_UNINITIALIZED; |
| } |
| |
| if (dsbd == NULL) { |
| WARN("invalid parameter: dsbd == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (dsbd->dwSize != sizeof(DSBUFFERDESC) && |
| dsbd->dwSize != sizeof(DSBUFFERDESC1)) { |
| WARN("invalid parameter: dsbd\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (ppdsb == NULL) { |
| WARN("invalid parameter: ppdsb == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (TRACE_ON(dsound)) { |
| TRACE("(structsize=%ld)\n",dsbd->dwSize); |
| TRACE("(flags=0x%08lx:\n",dsbd->dwFlags); |
| _dump_DSBCAPS(dsbd->dwFlags); |
| DPRINTF(")\n"); |
| TRACE("(bufferbytes=%ld)\n",dsbd->dwBufferBytes); |
| TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat); |
| } |
| |
| if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) { |
| if (dsbd->lpwfxFormat != NULL) { |
| WARN("invalid parameter: dsbd->lpwfxFormat must be NULL for " |
| "primary buffer\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (device->primary) { |
| WARN("Primary Buffer already created\n"); |
| IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(device->primary)); |
| *ppdsb = (LPDIRECTSOUNDBUFFER)(device->primary); |
| } else { |
| device->dsbd = *dsbd; |
| hres = PrimaryBufferImpl_Create(device, (PrimaryBufferImpl**)&(device->primary), &(device->dsbd)); |
| if (device->primary) { |
| IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(device->primary)); |
| *ppdsb = (LPDIRECTSOUNDBUFFER)(device->primary); |
| } else |
| WARN("PrimaryBufferImpl_Create failed\n"); |
| } |
| } else { |
| IDirectSoundBufferImpl * dsb; |
| |
| if (dsbd->lpwfxFormat == NULL) { |
| WARN("invalid parameter: dsbd->lpwfxFormat can't be NULL for " |
| "secondary buffer\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld," |
| "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n", |
| dsbd->lpwfxFormat->wFormatTag, dsbd->lpwfxFormat->nChannels, |
| dsbd->lpwfxFormat->nSamplesPerSec, |
| dsbd->lpwfxFormat->nAvgBytesPerSec, |
| dsbd->lpwfxFormat->nBlockAlign, |
| dsbd->lpwfxFormat->wBitsPerSample, dsbd->lpwfxFormat->cbSize); |
| |
| if (from8 && (dsbd->dwFlags & DSBCAPS_CTRL3D) && (dsbd->lpwfxFormat->nChannels != 1)) { |
| WARN("invalid parameter: 3D buffer format must be mono\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| hres = IDirectSoundBufferImpl_Create(device, (IDirectSoundBufferImpl**)&dsb, dsbd); |
| if (dsb) { |
| hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb); |
| if (*ppdsb) { |
| dsb->secondary = (SecondaryBufferImpl*)*ppdsb; |
| IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)*ppdsb); |
| } else |
| WARN("SecondaryBufferImpl_Create failed\n"); |
| } else |
| WARN("IDirectSoundBufferImpl_Create failed\n"); |
| } |
| |
| return hres; |
| } |
| |
| HRESULT DirectSoundDevice_DuplicateSoundBuffer( |
| DirectSoundDevice * device, |
| LPDIRECTSOUNDBUFFER psb, |
| LPLPDIRECTSOUNDBUFFER ppdsb) |
| { |
| HRESULT hres = DS_OK; |
| IDirectSoundBufferImpl* dsb; |
| TRACE("(%p,%p,%p)\n",device,psb,ppdsb); |
| |
| if (device == NULL) { |
| WARN("not initialized\n"); |
| return DSERR_UNINITIALIZED; |
| } |
| |
| if (psb == NULL) { |
| WARN("invalid parameter: psb == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (ppdsb == NULL) { |
| WARN("invalid parameter: ppdsb == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| /* make sure we have a secondary buffer */ |
| if ((PrimaryBufferImpl *)psb == device->primary) { |
| WARN("trying to duplicate primary buffer\n"); |
| *ppdsb = NULL; |
| return DSERR_INVALIDCALL; |
| } |
| |
| /* duplicate the actual buffer implementation */ |
| hres = IDirectSoundBufferImpl_Duplicate(device, &dsb, |
| ((SecondaryBufferImpl *)psb)->dsb); |
| |
| if (hres == DS_OK) { |
| /* create a new secondary buffer using the new implementation */ |
| hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb); |
| if (*ppdsb) { |
| dsb->secondary = (SecondaryBufferImpl*)*ppdsb; |
| IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)*ppdsb); |
| } else { |
| WARN("SecondaryBufferImpl_Create failed\n"); |
| IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)dsb); |
| IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER8)dsb); |
| } |
| } |
| |
| 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%08lx)\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. |
| * Gets exclusive access to buffer for writing. |
| */ |
| HRESULT DirectSoundDevice_AddBuffer( |
| DirectSoundDevice * device, |
| IDirectSoundBufferImpl * pDSB) |
| { |
| IDirectSoundBufferImpl **newbuffers; |
| HRESULT hr = DS_OK; |
| |
| TRACE("(%p, %p)\n", device, pDSB); |
| |
| RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE); |
| |
| if (device->buffers) |
| newbuffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1)); |
| else |
| newbuffers = HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1)); |
| |
| if (newbuffers) { |
| device->buffers = newbuffers; |
| device->buffers[device->nrofbuffers] = pDSB; |
| device->nrofbuffers++; |
| TRACE("buffer count is now %d\n", device->nrofbuffers); |
| } else { |
| ERR("out of memory for buffer list! Current buffer count is %d\n", device->nrofbuffers); |
| hr = DSERR_OUTOFMEMORY; |
| } |
| |
| RtlReleaseResource(&(device->buffer_list_lock)); |
| |
| return hr; |
| } |
| |
| /* |
| * Remove secondary buffer from buffer list. |
| * Gets exclusive access to buffer for writing. |
| */ |
| HRESULT DirectSoundDevice_RemoveBuffer( |
| DirectSoundDevice * device, |
| IDirectSoundBufferImpl * pDSB) |
| { |
| int i; |
| HRESULT hr = DS_OK; |
| |
| TRACE("(%p, %p)\n", device, pDSB); |
| |
| RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE); |
| |
| for (i = 0; i < device->nrofbuffers; i++) |
| if (device->buffers[i] == pDSB) |
| break; |
| |
| if (i < device->nrofbuffers) { |
| /* Put the last buffer of the list in the (now empty) position */ |
| device->buffers[i] = device->buffers[device->nrofbuffers - 1]; |
| device->nrofbuffers--; |
| device->buffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(LPDIRECTSOUNDBUFFER8)*device->nrofbuffers); |
| TRACE("buffer count is now %d\n", device->nrofbuffers); |
| } |
| |
| if (device->nrofbuffers == 0) { |
| HeapFree(GetProcessHeap(),0,device->buffers); |
| device->buffers = NULL; |
| } |
| |
| RtlReleaseResource(&(device->buffer_list_lock)); |
| |
| return hr; |
| } |
