ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

dsound: Refactor playback. 

Replace references of IDirectSoundImpl with DirectSoundDevice to
remove one level of indirection and remove the problem of a three
object circular reference.
This commit is contained in:
Robert Reif 2006-01-06 12:35:20 +01:00 committed by Alexandre Julliard
parent ead00327e9
commit e49a5c22fb
7 changed files with 256 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
dlls/dsound/buffer.c
View File

@ -277,7 +277,7 @@ static HRESULT WINAPI IDirectSoundBufferImpl_SetFrequency(
oldFreq = This->freq; oldFreq = This->freq;
This->freq = freq; This->freq = freq;
if (freq != oldFreq) { if (freq != oldFreq) {
This->freqAdjust = (freq << DSOUND_FREQSHIFT) / This->dsound->device->pwfx->nSamplesPerSec; This->freqAdjust = (freq << DSOUND_FREQSHIFT) / This->device->pwfx->nSamplesPerSec;
This->nAvgBytesPerSec = freq * This->pwfx->nBlockAlign; This->nAvgBytesPerSec = freq * This->pwfx->nBlockAlign;
DSOUND_RecalcFormat(This); DSOUND_RecalcFormat(This);
if (!This->hwbuf) if (!This->hwbuf)
@ -364,14 +364,14 @@ static ULONG WINAPI IDirectSoundBufferImpl_Release(LPDIRECTSOUNDBUFFER8 iface)
TRACE("(%p) ref was %ld\n", This, ref + 1); TRACE("(%p) ref was %ld\n", This, ref + 1);
if (!ref) { if (!ref) {
DSOUND_RemoveBuffer(This->dsound, This); DSOUND_RemoveBuffer(This->device, This);
This->lock.DebugInfo->Spare[0] = 0; This->lock.DebugInfo->Spare[0] = 0;
DeleteCriticalSection(&(This->lock)); DeleteCriticalSection(&(This->lock));
if (This->hwbuf) { if (This->hwbuf) {
IDsDriverBuffer_Release(This->hwbuf); IDsDriverBuffer_Release(This->hwbuf);
if (This->dsound->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) { if (This->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) {
This->buffer->ref--; This->buffer->ref--;
if (This->buffer->ref==0) { if (This->buffer->ref==0) {
HeapFree(GetProcessHeap(),0,This->buffer->memory); HeapFree(GetProcessHeap(),0,This->buffer->memory);
@ -399,22 +399,23 @@ DWORD DSOUND_CalcPlayPosition(IDirectSoundBufferImpl *This, DWORD pplay, DWORD p
{ {
DWORD bplay = This->buf_mixpos; DWORD bplay = This->buf_mixpos;
DWORD pmix = This->primary_mixpos; DWORD pmix = This->primary_mixpos;
DirectSoundDevice * device = This->device;
TRACE("(%p, pplay=%lu, pwrite=%lu)\n", This, pplay, pwrite); TRACE("(%p, pplay=%lu, pwrite=%lu)\n", This, pplay, pwrite);
/* the actual primary play position (pplay) is always behind last mixed (pmix), /* the actual primary play position (pplay) is always behind last mixed (pmix),
* unless the computer is too slow or something */ * unless the computer is too slow or something */
/* we need to know how far away we are from there */ /* we need to know how far away we are from there */
if (pmix < pplay) pmix += This->dsound->device->buflen; /* wraparound */ if (pmix < pplay) pmix += device->buflen; /* wraparound */
pmix -= pplay; pmix -= pplay;
/* detect buffer underrun */ /* detect buffer underrun */
if (pwrite < pplay) pwrite += This->dsound->device->buflen; /* wraparound */ if (pwrite < pplay) pwrite += device->buflen; /* wraparound */
pwrite -= pplay; pwrite -= pplay;
if (pmix > (ds_snd_queue_max * This->dsound->device->fraglen + pwrite + This->dsound->device->writelead)) { if (pmix > (ds_snd_queue_max * device->fraglen + pwrite + device->writelead)) {
WARN("detected an underrun: primary queue was %ld\n",pmix); WARN("detected an underrun: primary queue was %ld\n",pmix);
pmix = 0; pmix = 0;
} }
/* divide the offset by its sample size */ /* divide the offset by its sample size */
pmix /= This->dsound->device->pwfx->nBlockAlign; pmix /= device->pwfx->nBlockAlign;
TRACE("primary back-samples=%ld\n",pmix); TRACE("primary back-samples=%ld\n",pmix);
/* adjust for our frequency */ /* adjust for our frequency */
pmix = (pmix * This->freqAdjust) >> DSOUND_FREQSHIFT; pmix = (pmix * This->freqAdjust) >> DSOUND_FREQSHIFT;
@ -452,13 +453,13 @@ static HRESULT WINAPI IDirectSoundBufferImpl_GetCurrentPosition(
} else if (playpos) { } else if (playpos) {
DWORD pplay, pwrite; DWORD pplay, pwrite;
/* let's get this exact; first, recursively call GetPosition on the primary */ /* let's get this exact; first, recursively call GetPosition on the primary */
EnterCriticalSection(&(This->dsound->device->mixlock)); EnterCriticalSection(&(This->device->mixlock));
if (DSOUND_PrimaryGetPosition(This->dsound->device, &pplay, &pwrite) != DS_OK) if (DSOUND_PrimaryGetPosition(This->device, &pplay, &pwrite) != DS_OK)
WARN("DSOUND_PrimaryGetPosition failed\n"); WARN("DSOUND_PrimaryGetPosition failed\n");
/* detect HEL mode underrun */ /* detect HEL mode underrun */
if (!(This->dsound->device->hwbuf || This->dsound->device->pwqueue)) if (!(This->device->hwbuf || This->device->pwqueue))
TRACE("detected an underrun\n"); TRACE("detected an underrun\n");
if ((This->dsbd.dwFlags & DSBCAPS_GETCURRENTPOSITION2) || This->dsound->device->hwbuf) { if ((This->dsbd.dwFlags & DSBCAPS_GETCURRENTPOSITION2) || This->device->hwbuf) {
/* calculate play position using this */ /* calculate play position using this */
*playpos = DSOUND_CalcPlayPosition(This, pplay, pwrite); *playpos = DSOUND_CalcPlayPosition(This, pplay, pwrite);
} else { } else {
@ -468,11 +469,11 @@ static HRESULT WINAPI IDirectSoundBufferImpl_GetCurrentPosition(
* behind write cursor, hmm... */ * behind write cursor, hmm... */
/* let's just do what might work for Half-Life */ /* let's just do what might work for Half-Life */
DWORD wp; DWORD wp;
wp = (This->dsound->device->pwplay + ds_hel_margin) * This->dsound->device->fraglen; wp = (This->device->pwplay + ds_hel_margin) * This->device->fraglen;
wp %= This->dsound->device->buflen; wp %= This->device->buflen;
*playpos = DSOUND_CalcPlayPosition(This, wp, pwrite); *playpos = DSOUND_CalcPlayPosition(This, wp, pwrite);
} }
LeaveCriticalSection(&(This->dsound->device->mixlock)); LeaveCriticalSection(&(This->device->mixlock));
} }
if (writepos) if (writepos)
*writepos = This->buf_mixpos; *writepos = This->buf_mixpos;
@ -595,7 +596,7 @@ static HRESULT WINAPI IDirectSoundBufferImpl_Lock(
else else
This->probably_valid_to = writecursor; This->probably_valid_to = writecursor;
if (!(This->dsound->device->drvdesc.dwFlags & DSDDESC_DONTNEEDSECONDARYLOCK) && This->hwbuf) { if (!(This->device->drvdesc.dwFlags & DSDDESC_DONTNEEDSECONDARYLOCK) && This->hwbuf) {
hres = IDsDriverBuffer_Lock(This->hwbuf, hres = IDsDriverBuffer_Lock(This->hwbuf,
lplpaudioptr1, audiobytes1, lplpaudioptr1, audiobytes1,
lplpaudioptr2, audiobytes2, lplpaudioptr2, audiobytes2,
@ -748,7 +749,7 @@ static HRESULT WINAPI IDirectSoundBufferImpl_Unlock(
/* **** */ /* **** */
EnterCriticalSection(&(This->lock)); EnterCriticalSection(&(This->lock));
if (!(This->dsound->device->drvdesc.dwFlags & DSDDESC_DONTNEEDSECONDARYLOCK) && This->hwbuf) { if (!(This->device->drvdesc.dwFlags & DSDDESC_DONTNEEDSECONDARYLOCK) && This->hwbuf) {
hres = IDsDriverBuffer_Unlock(This->hwbuf, p1, x1, p2, x2); hres = IDsDriverBuffer_Unlock(This->hwbuf, p1, x1, p2, x2);
if (hres != DS_OK) if (hres != DS_OK)
WARN("IDsDriverBuffer_Unlock failed\n"); WARN("IDsDriverBuffer_Unlock failed\n");
@ -984,7 +985,7 @@ static const IDirectSoundBuffer8Vtbl dsbvt =
}; };
HRESULT IDirectSoundBufferImpl_Create( HRESULT IDirectSoundBufferImpl_Create(
IDirectSoundImpl *ds, DirectSoundDevice * device,
IDirectSoundBufferImpl **pdsb, IDirectSoundBufferImpl **pdsb,
LPCDSBUFFERDESC dsbd) LPCDSBUFFERDESC dsbd)
{ {
@ -993,7 +994,7 @@ HRESULT IDirectSoundBufferImpl_Create(
HRESULT err = DS_OK; HRESULT err = DS_OK;
DWORD capf = 0; DWORD capf = 0;
int use_hw, alloc_size, cp_size; int use_hw, alloc_size, cp_size;
TRACE("(%p,%p,%p)\n",ds,pdsb,dsbd); TRACE("(%p,%p,%p)\n",device,pdsb,dsbd);
if (dsbd->dwBufferBytes < DSBSIZE_MIN || dsbd->dwBufferBytes > DSBSIZE_MAX) { if (dsbd->dwBufferBytes < DSBSIZE_MIN || dsbd->dwBufferBytes > DSBSIZE_MAX) {
WARN("invalid parameter: dsbd->dwBufferBytes = %ld\n", dsbd->dwBufferBytes); WARN("invalid parameter: dsbd->dwBufferBytes = %ld\n", dsbd->dwBufferBytes);
@ -1013,7 +1014,7 @@ HRESULT IDirectSoundBufferImpl_Create(
dsb->ref = 0; dsb->ref = 0;
dsb->secondary = 0; dsb->secondary = 0;
dsb->dsound = ds; dsb->device = device;
dsb->lpVtbl = &dsbvt; dsb->lpVtbl = &dsbvt;
dsb->iks = NULL; dsb->iks = NULL;
@ -1056,8 +1057,8 @@ HRESULT IDirectSoundBufferImpl_Create(
if (wfex->wBitsPerSample==16) capf |= DSCAPS_SECONDARY16BIT; if (wfex->wBitsPerSample==16) capf |= DSCAPS_SECONDARY16BIT;
else capf |= DSCAPS_SECONDARY8BIT; else capf |= DSCAPS_SECONDARY8BIT;
use_hw = (ds->device->drvcaps.dwFlags & capf) == capf; use_hw = (device->drvcaps.dwFlags & capf) == capf;
TRACE("use_hw = 0x%08x, capf = 0x%08lx, ds->drvcaps.dwFlags = 0x%08lx\n", use_hw, capf, ds->device->drvcaps.dwFlags); TRACE("use_hw = 0x%08x, capf = 0x%08lx, device->drvcaps.dwFlags = 0x%08lx\n", use_hw, capf, device->drvcaps.dwFlags);
/* FIXME: check hardware sample rate mixing capabilities */ /* FIXME: check hardware sample rate mixing capabilities */
/* FIXME: check app hints for software/hardware buffer (STATIC, LOCHARDWARE, etc) */ /* FIXME: check app hints for software/hardware buffer (STATIC, LOCHARDWARE, etc) */
@ -1075,7 +1076,7 @@ HRESULT IDirectSoundBufferImpl_Create(
} }
/* Allocate system memory for buffer if applicable */ /* Allocate system memory for buffer if applicable */
if ((ds->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) || !use_hw) { if ((device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) || !use_hw) {
dsb->buffer->memory = HeapAlloc(GetProcessHeap(),0,dsb->buflen); dsb->buffer->memory = HeapAlloc(GetProcessHeap(),0,dsb->buflen);
if (dsb->buffer->memory == NULL) { if (dsb->buffer->memory == NULL) {
WARN("out of memory\n"); WARN("out of memory\n");
@ -1091,14 +1092,14 @@ HRESULT IDirectSoundBufferImpl_Create(
/* Allocate the hardware buffer */ /* Allocate the hardware buffer */
if (use_hw) { if (use_hw) {
err = IDsDriver_CreateSoundBuffer(ds->device->driver,wfex,dsbd->dwFlags,0, err = IDsDriver_CreateSoundBuffer(device->driver,wfex,dsbd->dwFlags,0,
&(dsb->buflen),&(dsb->buffer->memory), &(dsb->buflen),&(dsb->buffer->memory),
(LPVOID*)&(dsb->hwbuf)); (LPVOID*)&(dsb->hwbuf));
/* fall back to software buffer on failure */ /* fall back to software buffer on failure */
if (err != DS_OK) { if (err != DS_OK) {
TRACE("IDsDriver_CreateSoundBuffer failed, falling back to software buffer\n"); TRACE("IDsDriver_CreateSoundBuffer failed, falling back to software buffer\n");
use_hw = 0; use_hw = 0;
if (ds->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) { if (device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) {
dsb->buffer->memory = HeapAlloc(GetProcessHeap(),0,dsb->buflen); dsb->buffer->memory = HeapAlloc(GetProcessHeap(),0,dsb->buflen);
if (dsb->buffer->memory == NULL) { if (dsb->buffer->memory == NULL) {
WARN("out of memory\n"); WARN("out of memory\n");
@ -1125,7 +1126,7 @@ HRESULT IDirectSoundBufferImpl_Create(
dsb->state = STATE_STOPPED; dsb->state = STATE_STOPPED;
dsb->freqAdjust = (dsb->freq << DSOUND_FREQSHIFT) / dsb->freqAdjust = (dsb->freq << DSOUND_FREQSHIFT) /
ds->device->pwfx->nSamplesPerSec; device->pwfx->nSamplesPerSec;
dsb->nAvgBytesPerSec = dsb->freq * dsb->nAvgBytesPerSec = dsb->freq *
dsbd->lpwfxFormat->nBlockAlign; dsbd->lpwfxFormat->nBlockAlign;
@ -1157,7 +1158,7 @@ HRESULT IDirectSoundBufferImpl_Create(
/* register buffer if not primary */ /* register buffer if not primary */
if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) { if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
err = DSOUND_AddBuffer(ds, dsb); err = DSOUND_AddBuffer(device, dsb);
if (err != DS_OK) { if (err != DS_OK) {
HeapFree(GetProcessHeap(),0,dsb->buffer->memory); HeapFree(GetProcessHeap(),0,dsb->buffer->memory);
HeapFree(GetProcessHeap(),0,dsb->buffer); HeapFree(GetProcessHeap(),0,dsb->buffer);
@ -1235,8 +1236,10 @@ static ULONG WINAPI SecondaryBufferImpl_AddRef(LPDIRECTSOUNDBUFFER8 iface)
static ULONG WINAPI SecondaryBufferImpl_Release(LPDIRECTSOUNDBUFFER8 iface) static ULONG WINAPI SecondaryBufferImpl_Release(LPDIRECTSOUNDBUFFER8 iface)
{ {
SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface; SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
ULONG ref = InterlockedDecrement(&(This->ref)); ULONG ref;
TRACE("(%p) ref was %ld\n", This, ref + 1); TRACE("(%p)\n", This);
ref = InterlockedDecrement(&(This->ref));
TRACE("ref was %ld\n", ref + 1);
if (!ref) { if (!ref) {
This->dsb->secondary = NULL; This->dsb->secondary = NULL;

74
dlls/dsound/dsound.c
View File

@ -248,13 +248,8 @@ static ULONG WINAPI IDirectSoundImpl_Release(
TRACE("(%p) ref was %ld\n", This, ref + 1); TRACE("(%p) ref was %ld\n", This, ref + 1);
if (!ref) { if (!ref) {
if (This->device) { if (This->device)
if (DirectSoundDevice_Release(This->device) != 0) { DirectSoundDevice_Release(This->device);
/* device not released so make sure primary reference to This removed */
if (This->device->primary)
This->device->primary->dsound = NULL;
}
}
HeapFree(GetProcessHeap(),0,This); HeapFree(GetProcessHeap(),0,This);
TRACE("(%p) released\n", This); TRACE("(%p) released\n", This);
} }
@ -330,10 +325,9 @@ static HRESULT WINAPI DSOUND_CreateSoundBuffer(
WARN("Primary Buffer already created\n"); WARN("Primary Buffer already created\n");
IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(This->device->primary)); IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(This->device->primary));
*ppdsb = (LPDIRECTSOUNDBUFFER)(This->device->primary); *ppdsb = (LPDIRECTSOUNDBUFFER)(This->device->primary);
This->device->primary->dsound = This;
} else { } else {
This->device->dsbd = *dsbd; This->device->dsbd = *dsbd;
hres = PrimaryBufferImpl_Create(This, (PrimaryBufferImpl**)&(This->device->primary), &(This->device->dsbd)); hres = PrimaryBufferImpl_Create(This->device, (PrimaryBufferImpl**)&(This->device->primary), &(This->device->dsbd));
if (This->device->primary) { if (This->device->primary) {
IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(This->device->primary)); IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(This->device->primary));
*ppdsb = (LPDIRECTSOUNDBUFFER)(This->device->primary); *ppdsb = (LPDIRECTSOUNDBUFFER)(This->device->primary);
@ -362,7 +356,7 @@ static HRESULT WINAPI DSOUND_CreateSoundBuffer(
return DSERR_INVALIDPARAM; return DSERR_INVALIDPARAM;
} }
hres = IDirectSoundBufferImpl_Create(This, (IDirectSoundBufferImpl**)&dsb, dsbd); hres = IDirectSoundBufferImpl_Create(This->device, (IDirectSoundBufferImpl**)&dsb, dsbd);
if (dsb) { if (dsb) {
hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb); hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb);
if (*ppdsb) { if (*ppdsb) {
@ -474,8 +468,8 @@ static HRESULT WINAPI IDirectSoundImpl_DuplicateSoundBuffer(
return DSERR_INVALIDPARAM; return DSERR_INVALIDPARAM;
} }
/* FIXME: hack to make sure we have a secondary buffer */ /* make sure we have a secondary buffer */
if ((IDirectSoundImpl *)((SecondaryBufferImpl *)psb)->dsb == This) { if ((PrimaryBufferImpl *)psb == This->device->primary) {
WARN("trying to duplicate primary buffer\n"); WARN("trying to duplicate primary buffer\n");
*ppdsb = NULL; *ppdsb = NULL;
return DSERR_INVALIDCALL; return DSERR_INVALIDCALL;
@ -532,7 +526,7 @@ static HRESULT WINAPI IDirectSoundImpl_DuplicateSoundBuffer(
dsb->state = STATE_STOPPED; dsb->state = STATE_STOPPED;
dsb->playpos = 0; dsb->playpos = 0;
dsb->buf_mixpos = 0; dsb->buf_mixpos = 0;
dsb->dsound = This; dsb->device = This->device;
dsb->ds3db = NULL; dsb->ds3db = NULL;
dsb->iks = NULL; /* FIXME? */ dsb->iks = NULL; /* FIXME? */
dsb->secondary = NULL; dsb->secondary = NULL;
@ -555,7 +549,7 @@ static HRESULT WINAPI IDirectSoundImpl_DuplicateSoundBuffer(
dsb->lock.DebugInfo->Spare[0] = (DWORD_PTR)"DSOUNDBUFFER_lock"; dsb->lock.DebugInfo->Spare[0] = (DWORD_PTR)"DSOUNDBUFFER_lock";
/* register buffer */ /* register buffer */
hres = DSOUND_AddBuffer(This, dsb); hres = DSOUND_AddBuffer(This->device, dsb);
if (hres != DS_OK) { if (hres != DS_OK) {
IDirectSoundBuffer8_Release(psb); IDirectSoundBuffer8_Release(psb);
dsb->lock.DebugInfo->Spare[0] = 0; dsb->lock.DebugInfo->Spare[0] = 0;
@ -1855,32 +1849,32 @@ HRESULT WINAPI DirectSoundCreate8(
* Gets exclusive access to buffer for writing. * Gets exclusive access to buffer for writing.
*/ */
HRESULT DSOUND_AddBuffer( HRESULT DSOUND_AddBuffer(
IDirectSoundImpl * pDS, DirectSoundDevice * device,
IDirectSoundBufferImpl * pDSB) IDirectSoundBufferImpl * pDSB)
{ {
IDirectSoundBufferImpl **newbuffers; IDirectSoundBufferImpl **newbuffers;
HRESULT hr = DS_OK; HRESULT hr = DS_OK;
TRACE("(%p, %p)\n", pDS, pDSB); TRACE("(%p, %p)\n", device, pDSB);
RtlAcquireResourceExclusive(&(pDS->device->buffer_list_lock), TRUE); RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
if (pDS->device->buffers) if (device->buffers)
newbuffers = HeapReAlloc(GetProcessHeap(),0,pDS->device->buffers,sizeof(IDirectSoundBufferImpl*)*(pDS->device->nrofbuffers+1)); newbuffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
else else
newbuffers = HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl*)*(pDS->device->nrofbuffers+1)); newbuffers = HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
if (newbuffers) { if (newbuffers) {
pDS->device->buffers = newbuffers; device->buffers = newbuffers;
pDS->device->buffers[pDS->device->nrofbuffers] = pDSB; device->buffers[device->nrofbuffers] = pDSB;
pDS->device->nrofbuffers++; device->nrofbuffers++;
TRACE("buffer count is now %d\n", pDS->device->nrofbuffers); TRACE("buffer count is now %d\n", device->nrofbuffers);
} else { } else {
ERR("out of memory for buffer list! Current buffer count is %d\n", pDS->device->nrofbuffers); ERR("out of memory for buffer list! Current buffer count is %d\n", device->nrofbuffers);
hr = DSERR_OUTOFMEMORY; hr = DSERR_OUTOFMEMORY;
} }
RtlReleaseResource(&(pDS->device->buffer_list_lock)); RtlReleaseResource(&(device->buffer_list_lock));
return hr; return hr;
} }
@ -1890,34 +1884,34 @@ HRESULT DSOUND_AddBuffer(
* Gets exclusive access to buffer for writing. * Gets exclusive access to buffer for writing.
*/ */
HRESULT DSOUND_RemoveBuffer( HRESULT DSOUND_RemoveBuffer(
IDirectSoundImpl * pDS, DirectSoundDevice * device,
IDirectSoundBufferImpl * pDSB) IDirectSoundBufferImpl * pDSB)
{ {
int i; int i;
HRESULT hr = DS_OK; HRESULT hr = DS_OK;
TRACE("(%p, %p)\n", pDS, pDSB); TRACE("(%p, %p)\n", device, pDSB);
RtlAcquireResourceExclusive(&(pDS->device->buffer_list_lock), TRUE); RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
for (i = 0; i < pDS->device->nrofbuffers; i++) for (i = 0; i < device->nrofbuffers; i++)
if (pDS->device->buffers[i] == pDSB) if (device->buffers[i] == pDSB)
break; break;
if (i < pDS->device->nrofbuffers) { if (i < device->nrofbuffers) {
/* Put the last buffer of the list in the (now empty) position */ /* Put the last buffer of the list in the (now empty) position */
pDS->device->buffers[i] = pDS->device->buffers[pDS->device->nrofbuffers - 1]; device->buffers[i] = device->buffers[device->nrofbuffers - 1];
pDS->device->nrofbuffers--; device->nrofbuffers--;
pDS->device->buffers = HeapReAlloc(GetProcessHeap(),0,pDS->device->buffers,sizeof(LPDIRECTSOUNDBUFFER8)*pDS->device->nrofbuffers); device->buffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(LPDIRECTSOUNDBUFFER8)*device->nrofbuffers);
TRACE("buffer count is now %d\n", pDS->device->nrofbuffers); TRACE("buffer count is now %d\n", device->nrofbuffers);
} }
if (pDS->device->nrofbuffers == 0) { if (device->nrofbuffers == 0) {
HeapFree(GetProcessHeap(),0,pDS->device->buffers); HeapFree(GetProcessHeap(),0,device->buffers);
pDS->device->buffers = NULL; device->buffers = NULL;
} }
RtlReleaseResource(&(pDS->device->buffer_list_lock)); RtlReleaseResource(&(device->buffer_list_lock));
return hr; return hr;
} }

20
dlls/dsound/dsound_private.h
View File

@ -200,7 +200,7 @@ struct IDirectSoundBufferImpl
LONG ref; LONG ref;
/* IDirectSoundBufferImpl fields */ /* IDirectSoundBufferImpl fields */
SecondaryBufferImpl* secondary; SecondaryBufferImpl* secondary;
IDirectSoundImpl* dsound; DirectSoundDevice* device;
CRITICAL_SECTION lock; CRITICAL_SECTION lock;
PIDSDRIVERBUFFER hwbuf; PIDSDRIVERBUFFER hwbuf;
PWAVEFORMATEX pwfx; PWAVEFORMATEX pwfx;
@ -235,8 +235,8 @@ struct IDirectSoundBufferImpl
}; };
HRESULT IDirectSoundBufferImpl_Create( HRESULT IDirectSoundBufferImpl_Create(
IDirectSoundImpl *ds, DirectSoundDevice *device,
IDirectSoundBufferImpl **pdsb, IDirectSoundBufferImpl **ppdsb,
LPCDSBUFFERDESC dsbd); LPCDSBUFFERDESC dsbd);
HRESULT IDirectSoundBufferImpl_Destroy( HRESULT IDirectSoundBufferImpl_Destroy(
IDirectSoundBufferImpl *pdsb); IDirectSoundBufferImpl *pdsb);
@ -264,12 +264,12 @@ struct PrimaryBufferImpl
{ {
const IDirectSoundBuffer8Vtbl *lpVtbl; const IDirectSoundBuffer8Vtbl *lpVtbl;
LONG ref; LONG ref;
IDirectSoundImpl* dsound; DirectSoundDevice* device;
}; };
HRESULT PrimaryBufferImpl_Create( HRESULT PrimaryBufferImpl_Create(
IDirectSoundImpl *ds, DirectSoundDevice * device,
PrimaryBufferImpl **pdsb, PrimaryBufferImpl **ppdsb,
LPCDSBUFFERDESC dsbd); LPCDSBUFFERDESC dsbd);
/***************************************************************************** /*****************************************************************************
@ -413,11 +413,11 @@ struct IDirectSound3DListenerImpl
const IDirectSound3DListenerVtbl *lpVtbl; const IDirectSound3DListenerVtbl *lpVtbl;
LONG ref; LONG ref;
/* IDirectSound3DListenerImpl fields */ /* IDirectSound3DListenerImpl fields */
IDirectSoundImpl* dsound; DirectSoundDevice* device;
}; };
HRESULT IDirectSound3DListenerImpl_Create( HRESULT IDirectSound3DListenerImpl_Create(
PrimaryBufferImpl *pb, DirectSoundDevice *device,
IDirectSound3DListenerImpl **pdsl); IDirectSound3DListenerImpl **pdsl);
/***************************************************************************** /*****************************************************************************
@ -488,8 +488,8 @@ void DSOUND_RecalcFormat(IDirectSoundBufferImpl *dsb);
/* dsound.c */ /* dsound.c */
HRESULT DSOUND_AddBuffer(IDirectSoundImpl * pDS, IDirectSoundBufferImpl * pDSB); HRESULT DSOUND_AddBuffer(DirectSoundDevice *device, IDirectSoundBufferImpl * pDSB);
HRESULT DSOUND_RemoveBuffer(IDirectSoundImpl * pDS, IDirectSoundBufferImpl * pDSB); HRESULT DSOUND_RemoveBuffer(DirectSoundDevice *device, IDirectSoundBufferImpl * pDSB);
/* primary.c */ /* primary.c */

118
dlls/dsound/mixer.c
View File

@ -165,7 +165,7 @@ static inline BYTE cvtS16toU8(INT16 s)
static inline void cp_fields(const IDirectSoundBufferImpl *dsb, BYTE *ibuf, BYTE *obuf ) static inline void cp_fields(const IDirectSoundBufferImpl *dsb, BYTE *ibuf, BYTE *obuf )
{ {
DirectSoundDevice * device = dsb->dsound->device; DirectSoundDevice * device = dsb->device;
INT fl,fr; INT fl,fr;
if (dsb->pwfx->wBitsPerSample == 8) { if (dsb->pwfx->wBitsPerSample == 8) {
@ -215,16 +215,16 @@ static INT DSOUND_MixerNorm(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
INT i, size, ipos, ilen; INT i, size, ipos, ilen;
BYTE *ibp, *obp; BYTE *ibp, *obp;
INT iAdvance = dsb->pwfx->nBlockAlign; INT iAdvance = dsb->pwfx->nBlockAlign;
INT oAdvance = dsb->dsound->device->pwfx->nBlockAlign; INT oAdvance = dsb->device->pwfx->nBlockAlign;
ibp = dsb->buffer->memory + dsb->buf_mixpos; ibp = dsb->buffer->memory + dsb->buf_mixpos;
obp = buf; obp = buf;
TRACE("(%p, %p, %p), buf_mixpos=%ld\n", dsb, ibp, obp, dsb->buf_mixpos); TRACE("(%p, %p, %p), buf_mixpos=%ld\n", dsb, ibp, obp, dsb->buf_mixpos);
/* Check for the best case */ /* Check for the best case */
if ((dsb->freq == dsb->dsound->device->pwfx->nSamplesPerSec) && if ((dsb->freq == dsb->device->pwfx->nSamplesPerSec) &&
(dsb->pwfx->wBitsPerSample == dsb->dsound->device->pwfx->wBitsPerSample) && (dsb->pwfx->wBitsPerSample == dsb->device->pwfx->wBitsPerSample) &&
(dsb->pwfx->nChannels == dsb->dsound->device->pwfx->nChannels)) { (dsb->pwfx->nChannels == dsb->device->pwfx->nChannels)) {
INT bytesleft = dsb->buflen - dsb->buf_mixpos; INT bytesleft = dsb->buflen - dsb->buf_mixpos;
TRACE("(%p) Best case\n", dsb); TRACE("(%p) Best case\n", dsb);
if (len <= bytesleft ) if (len <= bytesleft )
@ -237,9 +237,9 @@ static INT DSOUND_MixerNorm(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
} }
/* Check for same sample rate */ /* Check for same sample rate */
if (dsb->freq == dsb->dsound->device->pwfx->nSamplesPerSec) { if (dsb->freq == dsb->device->pwfx->nSamplesPerSec) {
TRACE("(%p) Same sample rate %ld = primary %ld\n", dsb, TRACE("(%p) Same sample rate %ld = primary %ld\n", dsb,
dsb->freq, dsb->dsound->device->pwfx->nSamplesPerSec); dsb->freq, dsb->device->pwfx->nSamplesPerSec);
ilen = 0; ilen = 0;
for (i = 0; i < len; i += oAdvance) { for (i = 0; i < len; i += oAdvance) {
cp_fields(dsb, ibp, obp ); cp_fields(dsb, ibp, obp );
@ -261,7 +261,7 @@ static INT DSOUND_MixerNorm(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
* TransGaming Technologies Inc. */ * TransGaming Technologies Inc. */
/* FIXME("(%p) Adjusting frequency: %ld -> %ld (need optimization)\n", /* FIXME("(%p) Adjusting frequency: %ld -> %ld (need optimization)\n",
dsb, dsb->freq, dsb->dsound->device->pwfx->nSamplesPerSec); */ dsb, dsb->freq, dsb->device->pwfx->nSamplesPerSec); */
size = len / oAdvance; size = len / oAdvance;
ilen = 0; ilen = 0;
@ -299,11 +299,11 @@ static void DSOUND_MixerVol(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
/* with a mono primary buffer, it could sound very weird using */ /* with a mono primary buffer, it could sound very weird using */
/* this method. Oh well, tough patooties. */ /* this method. Oh well, tough patooties. */
switch (dsb->dsound->device->pwfx->wBitsPerSample) { switch (dsb->device->pwfx->wBitsPerSample) {
case 8: case 8:
/* 8-bit WAV is unsigned, but we need to operate */ /* 8-bit WAV is unsigned, but we need to operate */
/* on signed data for this to work properly */ /* on signed data for this to work properly */
switch (dsb->dsound->device->pwfx->nChannels) { switch (dsb->device->pwfx->nChannels) {
case 1: case 1:
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
INT val = *bpc - 128; INT val = *bpc - 128;
@ -324,13 +324,13 @@ static void DSOUND_MixerVol(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
} }
break; break;
default: default:
FIXME("doesn't support %d channels\n", dsb->dsound->device->pwfx->nChannels); FIXME("doesn't support %d channels\n", dsb->device->pwfx->nChannels);
break; break;
} }
break; break;
case 16: case 16:
/* 16-bit WAV is signed -- much better */ /* 16-bit WAV is signed -- much better */
switch (dsb->dsound->device->pwfx->nChannels) { switch (dsb->device->pwfx->nChannels) {
case 1: case 1:
for (i = 0; i < len; i += 2) { for (i = 0; i < len; i += 2) {
*bps = (*bps * dsb->cvolpan.dwTotalLeftAmpFactor) >> 16; *bps = (*bps * dsb->cvolpan.dwTotalLeftAmpFactor) >> 16;
@ -346,12 +346,12 @@ static void DSOUND_MixerVol(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
} }
break; break;
default: default:
FIXME("doesn't support %d channels\n", dsb->dsound->device->pwfx->nChannels); FIXME("doesn't support %d channels\n", dsb->device->pwfx->nChannels);
break; break;
} }
break; break;
default: default:
FIXME("doesn't support %d bit samples\n", dsb->dsound->device->pwfx->wBitsPerSample); FIXME("doesn't support %d bit samples\n", dsb->device->pwfx->wBitsPerSample);
break; break;
} }
} }
@ -382,7 +382,7 @@ static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWO
len = fraglen; len = fraglen;
if (!(dsb->playflags & DSBPLAY_LOOPING)) { if (!(dsb->playflags & DSBPLAY_LOOPING)) {
int secondary_remainder = dsb->buflen - dsb->buf_mixpos; int secondary_remainder = dsb->buflen - dsb->buf_mixpos;
int adjusted_remainder = MulDiv(dsb->dsound->device->pwfx->nAvgBytesPerSec, secondary_remainder, dsb->nAvgBytesPerSec); int adjusted_remainder = MulDiv(dsb->device->pwfx->nAvgBytesPerSec, secondary_remainder, dsb->nAvgBytesPerSec);
assert(adjusted_remainder >= 0); assert(adjusted_remainder >= 0);
TRACE("secondary_remainder = %d, adjusted_remainder = %d, len = %d\n", secondary_remainder, adjusted_remainder, len); TRACE("secondary_remainder = %d, adjusted_remainder = %d, len = %d\n", secondary_remainder, adjusted_remainder, len);
if (adjusted_remainder < len) { if (adjusted_remainder < len) {
@ -393,13 +393,13 @@ static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWO
return 0; return 0;
} }
if (len % dsb->dsound->device->pwfx->nBlockAlign) { if (len % dsb->device->pwfx->nBlockAlign) {
INT nBlockAlign = dsb->dsound->device->pwfx->nBlockAlign; INT nBlockAlign = dsb->device->pwfx->nBlockAlign;
ERR("length not a multiple of block size, len = %d, block size = %d\n", len, nBlockAlign); ERR("length not a multiple of block size, len = %d, block size = %d\n", len, nBlockAlign);
len = (len / nBlockAlign) * nBlockAlign; /* data alignment */ len = (len / nBlockAlign) * nBlockAlign; /* data alignment */
} }
if ((buf = ibuf = DSOUND_tmpbuffer(dsb->dsound->device, len)) == NULL) if ((buf = ibuf = DSOUND_tmpbuffer(dsb->device, len)) == NULL)
return 0; return 0;
TRACE("MixInBuffer (%p) len = %d, dest = %ld\n", dsb, len, writepos); TRACE("MixInBuffer (%p) len = %d, dest = %ld\n", dsb, len, writepos);
@ -410,13 +410,13 @@ static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWO
(dsb->dsbd.dwFlags & DSBCAPS_CTRL3D)) (dsb->dsbd.dwFlags & DSBCAPS_CTRL3D))
DSOUND_MixerVol(dsb, ibuf, len); DSOUND_MixerVol(dsb, ibuf, len);
if (dsb->dsound->device->pwfx->wBitsPerSample == 8) { if (dsb->device->pwfx->wBitsPerSample == 8) {
BYTE *obuf = dsb->dsound->device->buffer + writepos; BYTE *obuf = dsb->device->buffer + writepos;
if ((writepos + len) <= dsb->dsound->device->buflen) if ((writepos + len) <= dsb->device->buflen)
todo = len; todo = len;
else else
todo = dsb->dsound->device->buflen - writepos; todo = dsb->device->buflen - writepos;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 8-bit WAV is unsigned */ /* 8-bit WAV is unsigned */
@ -429,7 +429,7 @@ static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWO
if (todo < len) { if (todo < len) {
todo = len - todo; todo = len - todo;
obuf = dsb->dsound->device->buffer; obuf = dsb->device->buffer;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 8-bit WAV is unsigned */ /* 8-bit WAV is unsigned */
@ -444,12 +444,12 @@ static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWO
INT16 *ibufs, *obufs; INT16 *ibufs, *obufs;
ibufs = (INT16 *) ibuf; ibufs = (INT16 *) ibuf;
obufs = (INT16 *)(dsb->dsound->device->buffer + writepos); obufs = (INT16 *)(dsb->device->buffer + writepos);
if ((writepos + len) <= dsb->dsound->device->buflen) if ((writepos + len) <= dsb->device->buflen)
todo = len / 2; todo = len / 2;
else else
todo = (dsb->dsound->device->buflen - writepos) / 2; todo = (dsb->device->buflen - writepos) / 2;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 16-bit WAV is signed */ /* 16-bit WAV is signed */
@ -462,7 +462,7 @@ static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWO
if (todo < (len / 2)) { if (todo < (len / 2)) {
todo = (len / 2) - todo; todo = (len / 2) - todo;
obufs = (INT16 *)dsb->dsound->device->buffer; obufs = (INT16 *)dsb->device->buffer;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 16-bit WAV is signed */ /* 16-bit WAV is signed */
@ -508,13 +508,13 @@ static void DSOUND_PhaseCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, DWOR
TRACE("(%p,%ld,%ld)\n",dsb,writepos,len); TRACE("(%p,%ld,%ld)\n",dsb,writepos,len);
if (len % dsb->dsound->device->pwfx->nBlockAlign) { if (len % dsb->device->pwfx->nBlockAlign) {
INT nBlockAlign = dsb->dsound->device->pwfx->nBlockAlign; INT nBlockAlign = dsb->device->pwfx->nBlockAlign;
ERR("length not a multiple of block size, len = %ld, block size = %d\n", len, nBlockAlign); ERR("length not a multiple of block size, len = %ld, block size = %d\n", len, nBlockAlign);
len = (len / nBlockAlign) * nBlockAlign; /* data alignment */ len = (len / nBlockAlign) * nBlockAlign; /* data alignment */
} }
if ((buf = ibuf = DSOUND_tmpbuffer(dsb->dsound->device, len)) == NULL) if ((buf = ibuf = DSOUND_tmpbuffer(dsb->device, len)) == NULL)
return; return;
TRACE("PhaseCancel (%p) len = %ld, dest = %ld\n", dsb, len, writepos); TRACE("PhaseCancel (%p) len = %ld, dest = %ld\n", dsb, len, writepos);
@ -526,13 +526,13 @@ static void DSOUND_PhaseCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, DWOR
DSOUND_MixerVol(dsb, ibuf, len); DSOUND_MixerVol(dsb, ibuf, len);
/* subtract instead of add, to phase out premixed data */ /* subtract instead of add, to phase out premixed data */
if (dsb->dsound->device->pwfx->wBitsPerSample == 8) { if (dsb->device->pwfx->wBitsPerSample == 8) {
BYTE *obuf = dsb->dsound->device->buffer + writepos; BYTE *obuf = dsb->device->buffer + writepos;
if ((writepos + len) <= dsb->dsound->device->buflen) if ((writepos + len) <= dsb->device->buflen)
todo = len; todo = len;
else else
todo = dsb->dsound->device->buflen - writepos; todo = dsb->device->buflen - writepos;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 8-bit WAV is unsigned */ /* 8-bit WAV is unsigned */
@ -545,7 +545,7 @@ static void DSOUND_PhaseCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, DWOR
if (todo < len) { if (todo < len) {
todo = len - todo; todo = len - todo;
obuf = dsb->dsound->device->buffer; obuf = dsb->device->buffer;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 8-bit WAV is unsigned */ /* 8-bit WAV is unsigned */
@ -560,12 +560,12 @@ static void DSOUND_PhaseCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, DWOR
INT16 *ibufs, *obufs; INT16 *ibufs, *obufs;
ibufs = (INT16 *) ibuf; ibufs = (INT16 *) ibuf;
obufs = (INT16 *)(dsb->dsound->device->buffer + writepos); obufs = (INT16 *)(dsb->device->buffer + writepos);
if ((writepos + len) <= dsb->dsound->device->buflen) if ((writepos + len) <= dsb->device->buflen)
todo = len / 2; todo = len / 2;
else else
todo = (dsb->dsound->device->buflen - writepos) / 2; todo = (dsb->device->buflen - writepos) / 2;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 16-bit WAV is signed */ /* 16-bit WAV is signed */
@ -578,7 +578,7 @@ static void DSOUND_PhaseCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, DWOR
if (todo < (len / 2)) { if (todo < (len / 2)) {
todo = (len / 2) - todo; todo = (len / 2) - todo;
obufs = (INT16 *)dsb->dsound->device->buffer; obufs = (INT16 *)dsb->device->buffer;
for (i = 0; i < todo; i++) { for (i = 0; i < todo; i++) {
/* 16-bit WAV is signed */ /* 16-bit WAV is signed */
@ -596,10 +596,10 @@ static void DSOUND_MixCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, BOOL c
{ {
DWORD size, flen, len, npos, nlen; DWORD size, flen, len, npos, nlen;
INT iAdvance = dsb->pwfx->nBlockAlign; INT iAdvance = dsb->pwfx->nBlockAlign;
INT oAdvance = dsb->dsound->device->pwfx->nBlockAlign; INT oAdvance = dsb->device->pwfx->nBlockAlign;
/* determine amount of premixed data to cancel */ /* determine amount of premixed data to cancel */
DWORD primary_done = DWORD primary_done =
((dsb->primary_mixpos < writepos) ? dsb->dsound->device->buflen : 0) + ((dsb->primary_mixpos < writepos) ? dsb->device->buflen : 0) +
dsb->primary_mixpos - writepos; dsb->primary_mixpos - writepos;
TRACE("(%p, %ld), buf_mixpos=%ld\n", dsb, writepos, dsb->buf_mixpos); TRACE("(%p, %ld), buf_mixpos=%ld\n", dsb, writepos, dsb->buf_mixpos);
@ -624,9 +624,9 @@ static void DSOUND_MixCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, BOOL c
flen = dsb->freqAcc; flen = dsb->freqAcc;
nlen = len / dsb->pwfx->nBlockAlign; nlen = len / dsb->pwfx->nBlockAlign;
nlen = ((nlen << DSOUND_FREQSHIFT) + flen) / dsb->freqAdjust; nlen = ((nlen << DSOUND_FREQSHIFT) + flen) / dsb->freqAdjust;
nlen *= dsb->dsound->device->pwfx->nBlockAlign; nlen *= dsb->device->pwfx->nBlockAlign;
writepos = writepos =
((dsb->primary_mixpos < nlen) ? dsb->dsound->device->buflen : 0) + ((dsb->primary_mixpos < nlen) ? dsb->device->buflen : 0) +
dsb->primary_mixpos - nlen; dsb->primary_mixpos - nlen;
} }
@ -645,7 +645,7 @@ void DSOUND_MixCancelAt(IDirectSoundBufferImpl *dsb, DWORD buf_writepos)
#if 0 #if 0
DWORD i, size, flen, len, npos, nlen; DWORD i, size, flen, len, npos, nlen;
INT iAdvance = dsb->pwfx->nBlockAlign; INT iAdvance = dsb->pwfx->nBlockAlign;
INT oAdvance = dsb->dsound->device->pwfx->nBlockAlign; INT oAdvance = dsb->device->pwfx->nBlockAlign;
/* determine amount of premixed data to cancel */ /* determine amount of premixed data to cancel */
DWORD buf_done = DWORD buf_done =
((dsb->buf_mixpos < buf_writepos) ? dsb->buflen : 0) + ((dsb->buf_mixpos < buf_writepos) ? dsb->buflen : 0) +
@ -655,7 +655,7 @@ void DSOUND_MixCancelAt(IDirectSoundBufferImpl *dsb, DWORD buf_writepos)
WARN("(%p, %ld), buf_mixpos=%ld\n", dsb, buf_writepos, dsb->buf_mixpos); WARN("(%p, %ld), buf_mixpos=%ld\n", dsb, buf_writepos, dsb->buf_mixpos);
/* since this is not implemented yet, just cancel *ALL* prebuffering for now /* since this is not implemented yet, just cancel *ALL* prebuffering for now
* (which is faster anyway when there's only a single secondary buffer) */ * (which is faster anyway when there's only a single secondary buffer) */
dsb->dsound->device->need_remix = TRUE; dsb->device->need_remix = TRUE;
} }
void DSOUND_ForceRemix(IDirectSoundBufferImpl *dsb) void DSOUND_ForceRemix(IDirectSoundBufferImpl *dsb)
@ -663,7 +663,7 @@ void DSOUND_ForceRemix(IDirectSoundBufferImpl *dsb)
TRACE("(%p)\n",dsb); TRACE("(%p)\n",dsb);
EnterCriticalSection(&dsb->lock); EnterCriticalSection(&dsb->lock);
if (dsb->state == STATE_PLAYING) if (dsb->state == STATE_PLAYING)
dsb->dsound->device->need_remix = TRUE; dsb->device->need_remix = TRUE;
LeaveCriticalSection(&dsb->lock); LeaveCriticalSection(&dsb->lock);
} }
@ -677,11 +677,11 @@ static DWORD DSOUND_MixOne(IDirectSoundBufferImpl *dsb, DWORD playpos, DWORD wri
((dsb->buf_mixpos < buf_writepos) ? dsb->buflen : 0) + ((dsb->buf_mixpos < buf_writepos) ? dsb->buflen : 0) +
dsb->buf_mixpos - buf_writepos; dsb->buf_mixpos - buf_writepos;
DWORD primary_done = DWORD primary_done =
((dsb->primary_mixpos < writepos) ? dsb->dsound->device->buflen : 0) + ((dsb->primary_mixpos < writepos) ? dsb->device->buflen : 0) +
dsb->primary_mixpos - writepos; dsb->primary_mixpos - writepos;
DWORD adv_done = DWORD adv_done =
((dsb->dsound->device->mixpos < writepos) ? dsb->dsound->device->buflen : 0) + ((dsb->device->mixpos < writepos) ? dsb->device->buflen : 0) +
dsb->dsound->device->mixpos - writepos; dsb->device->mixpos - writepos;
DWORD played = DWORD played =
((buf_writepos < dsb->playpos) ? dsb->buflen : 0) + ((buf_writepos < dsb->playpos) ? dsb->buflen : 0) +
buf_writepos - dsb->playpos; buf_writepos - dsb->playpos;
@ -750,7 +750,7 @@ static DWORD DSOUND_MixOne(IDirectSoundBufferImpl *dsb, DWORD playpos, DWORD wri
probably_valid_left = MulDiv(probably_valid_left, probably_valid_left = MulDiv(probably_valid_left,
1 << DSOUND_FREQSHIFT, 1 << DSOUND_FREQSHIFT,
dsb->pwfx->nBlockAlign * dsb->freqAdjust) * dsb->pwfx->nBlockAlign * dsb->freqAdjust) *
dsb->dsound->device->pwfx->nBlockAlign; dsb->device->pwfx->nBlockAlign;
/* check whether to clip mix_len */ /* check whether to clip mix_len */
if (probably_valid_left < mixlen) { if (probably_valid_left < mixlen) {
TRACE("clipping to probably_valid_left=%ld\n", probably_valid_left); TRACE("clipping to probably_valid_left=%ld\n", probably_valid_left);
@ -768,7 +768,7 @@ static DWORD DSOUND_MixOne(IDirectSoundBufferImpl *dsb, DWORD playpos, DWORD wri
len = mixlen - primary_done; len = mixlen - primary_done;
TRACE("remaining mixlen=%ld\n", len); TRACE("remaining mixlen=%ld\n", len);
if (len < dsb->dsound->device->fraglen) { if (len < dsb->device->fraglen) {
/* smaller than a fragment, wait until it gets larger /* smaller than a fragment, wait until it gets larger
* before we take the mixing overhead */ * before we take the mixing overhead */
TRACE("mixlen not worth it, deferring mixing\n"); TRACE("mixlen not worth it, deferring mixing\n");
@ -779,20 +779,20 @@ static DWORD DSOUND_MixOne(IDirectSoundBufferImpl *dsb, DWORD playpos, DWORD wri
/* ok, we know how much to mix, let's go */ /* ok, we know how much to mix, let's go */
still_behind = (adv_done > primary_done); still_behind = (adv_done > primary_done);
while (len) { while (len) {
slen = dsb->dsound->device->buflen - dsb->primary_mixpos; slen = dsb->device->buflen - dsb->primary_mixpos;
if (slen > len) slen = len; if (slen > len) slen = len;
slen = DSOUND_MixInBuffer(dsb, dsb->primary_mixpos, slen); slen = DSOUND_MixInBuffer(dsb, dsb->primary_mixpos, slen);
if ((dsb->primary_mixpos < dsb->dsound->device->mixpos) && if ((dsb->primary_mixpos < dsb->device->mixpos) &&
(dsb->primary_mixpos + slen >= dsb->dsound->device->mixpos)) (dsb->primary_mixpos + slen >= dsb->device->mixpos))
still_behind = FALSE; still_behind = FALSE;
dsb->primary_mixpos += slen; len -= slen; dsb->primary_mixpos += slen; len -= slen;
dsb->primary_mixpos %= dsb->dsound->device->buflen; dsb->primary_mixpos %= dsb->device->buflen;
if ((dsb->state == STATE_STOPPED) || !slen) break; if ((dsb->state == STATE_STOPPED) || !slen) break;
} }
TRACE("new primary_mixpos=%ld, primary_advbase=%ld\n", dsb->primary_mixpos, dsb->dsound->device->mixpos); TRACE("new primary_mixpos=%ld, primary_advbase=%ld\n", dsb->primary_mixpos, dsb->device->mixpos);
TRACE("mixed data len=%ld, still_behind=%d\n", mixlen-len, still_behind); TRACE("mixed data len=%ld, still_behind=%d\n", mixlen-len, still_behind);
post_mix: post_mix:
@ -812,9 +812,9 @@ post_mix:
* advance its underrun detector...*/ * advance its underrun detector...*/
if (still_behind) return 0; if (still_behind) return 0;
if ((mixlen - len) < primary_done) return 0; if ((mixlen - len) < primary_done) return 0;
slen = ((dsb->primary_mixpos < dsb->dsound->device->mixpos) ? slen = ((dsb->primary_mixpos < dsb->device->mixpos) ?
dsb->dsound->device->buflen : 0) + dsb->primary_mixpos - dsb->device->buflen : 0) + dsb->primary_mixpos -
dsb->dsound->device->mixpos; dsb->device->mixpos;
if (slen > mixlen) { if (slen > mixlen) {
/* the primary_done and still_behind checks above should have worked */ /* the primary_done and still_behind checks above should have worked */
FIXME("problem with advancement calculation (advlen=%ld > mixlen=%ld)\n", slen, mixlen); FIXME("problem with advancement calculation (advlen=%ld > mixlen=%ld)\n", slen, mixlen);

57
dlls/dsound/primary.c
View File

@ -326,7 +326,7 @@ HRESULT DSOUND_PrimaryGetPosition(DirectSoundDevice *device, LPDWORD playpos, LP
static HRESULT WINAPI PrimaryBufferImpl_SetFormat( static HRESULT WINAPI PrimaryBufferImpl_SetFormat(
LPDIRECTSOUNDBUFFER8 iface,LPCWAVEFORMATEX wfex LPDIRECTSOUNDBUFFER8 iface,LPCWAVEFORMATEX wfex
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
HRESULT err = DS_OK; HRESULT err = DS_OK;
int i, alloc_size, cp_size; int i, alloc_size, cp_size;
DWORD nSamplesPerSec; DWORD nSamplesPerSec;
@ -433,7 +433,7 @@ done:
static HRESULT WINAPI PrimaryBufferImpl_SetVolume( static HRESULT WINAPI PrimaryBufferImpl_SetVolume(
LPDIRECTSOUNDBUFFER8 iface,LONG vol LPDIRECTSOUNDBUFFER8 iface,LONG vol
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
DWORD ampfactors; DWORD ampfactors;
DSVOLUMEPAN volpan; DSVOLUMEPAN volpan;
HRESULT hres = DS_OK; HRESULT hres = DS_OK;
@ -478,7 +478,7 @@ static HRESULT WINAPI PrimaryBufferImpl_SetVolume(
static HRESULT WINAPI PrimaryBufferImpl_GetVolume( static HRESULT WINAPI PrimaryBufferImpl_GetVolume(
LPDIRECTSOUNDBUFFER8 iface,LPLONG vol LPDIRECTSOUNDBUFFER8 iface,LPLONG vol
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
DWORD ampfactors; DWORD ampfactors;
DSVOLUMEPAN volpan; DSVOLUMEPAN volpan;
TRACE("(%p,%p)\n", iface, vol); TRACE("(%p,%p)\n", iface, vol);
@ -515,7 +515,7 @@ static HRESULT WINAPI PrimaryBufferImpl_SetFrequency(
static HRESULT WINAPI PrimaryBufferImpl_Play( static HRESULT WINAPI PrimaryBufferImpl_Play(
LPDIRECTSOUNDBUFFER8 iface,DWORD reserved1,DWORD reserved2,DWORD flags LPDIRECTSOUNDBUFFER8 iface,DWORD reserved1,DWORD reserved2,DWORD flags
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%08lx,%08lx,%08lx)\n", iface, reserved1, reserved2, flags); TRACE("(%p,%08lx,%08lx,%08lx)\n", iface, reserved1, reserved2, flags);
if (!(flags & DSBPLAY_LOOPING)) { if (!(flags & DSBPLAY_LOOPING)) {
@ -539,7 +539,7 @@ static HRESULT WINAPI PrimaryBufferImpl_Play(
static HRESULT WINAPI PrimaryBufferImpl_Stop(LPDIRECTSOUNDBUFFER8 iface) static HRESULT WINAPI PrimaryBufferImpl_Stop(LPDIRECTSOUNDBUFFER8 iface)
{ {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p)\n", iface); TRACE("(%p)\n", iface);
/* **** */ /* **** */
@ -571,7 +571,7 @@ static ULONG WINAPI PrimaryBufferImpl_Release(LPDIRECTSOUNDBUFFER8 iface)
TRACE("(%p) ref was %ld\n", This, ref + 1); TRACE("(%p) ref was %ld\n", This, ref + 1);
if (!ref) { if (!ref) {
This->dsound->device->primary = NULL; This->device->primary = NULL;
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
TRACE("(%p) released\n", This); TRACE("(%p) released\n", This);
} }
@ -582,7 +582,7 @@ static HRESULT WINAPI PrimaryBufferImpl_GetCurrentPosition(
LPDIRECTSOUNDBUFFER8 iface,LPDWORD playpos,LPDWORD writepos LPDIRECTSOUNDBUFFER8 iface,LPDWORD playpos,LPDWORD writepos
) { ) {
HRESULT hres; HRESULT hres;
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%p,%p)\n", iface, playpos, writepos); TRACE("(%p,%p,%p)\n", iface, playpos, writepos);
hres = DSOUND_PrimaryGetPosition(device, playpos, writepos); hres = DSOUND_PrimaryGetPosition(device, playpos, writepos);
@ -603,7 +603,7 @@ static HRESULT WINAPI PrimaryBufferImpl_GetCurrentPosition(
static HRESULT WINAPI PrimaryBufferImpl_GetStatus( static HRESULT WINAPI PrimaryBufferImpl_GetStatus(
LPDIRECTSOUNDBUFFER8 iface,LPDWORD status LPDIRECTSOUNDBUFFER8 iface,LPDWORD status
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%p)\n", iface, status); TRACE("(%p,%p)\n", iface, status);
if (status == NULL) { if (status == NULL) {
@ -628,7 +628,7 @@ static HRESULT WINAPI PrimaryBufferImpl_GetFormat(
LPDWORD wfwritten) LPDWORD wfwritten)
{ {
DWORD size; DWORD size;
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%p,%ld,%p)\n", iface, lpwf, wfsize, wfwritten); TRACE("(%p,%p,%ld,%p)\n", iface, lpwf, wfsize, wfwritten);
size = sizeof(WAVEFORMATEX) + device->pwfx->cbSize; size = sizeof(WAVEFORMATEX) + device->pwfx->cbSize;
@ -659,7 +659,7 @@ static HRESULT WINAPI PrimaryBufferImpl_GetFormat(
static HRESULT WINAPI PrimaryBufferImpl_Lock( static HRESULT WINAPI PrimaryBufferImpl_Lock(
LPDIRECTSOUNDBUFFER8 iface,DWORD writecursor,DWORD writebytes,LPVOID lplpaudioptr1,LPDWORD audiobytes1,LPVOID lplpaudioptr2,LPDWORD audiobytes2,DWORD flags LPDIRECTSOUNDBUFFER8 iface,DWORD writecursor,DWORD writebytes,LPVOID lplpaudioptr1,LPDWORD audiobytes1,LPVOID lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%ld,%ld,%p,%p,%p,%p,0x%08lx) at %ld\n", TRACE("(%p,%ld,%ld,%p,%p,%p,%p,0x%08lx) at %ld\n",
iface, iface,
writecursor, writecursor,
@ -742,7 +742,7 @@ static HRESULT WINAPI PrimaryBufferImpl_SetCurrentPosition(
static HRESULT WINAPI PrimaryBufferImpl_SetPan( static HRESULT WINAPI PrimaryBufferImpl_SetPan(
LPDIRECTSOUNDBUFFER8 iface,LONG pan LPDIRECTSOUNDBUFFER8 iface,LONG pan
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
DWORD ampfactors; DWORD ampfactors;
DSVOLUMEPAN volpan; DSVOLUMEPAN volpan;
HRESULT hres = DS_OK; HRESULT hres = DS_OK;
@ -787,7 +787,7 @@ static HRESULT WINAPI PrimaryBufferImpl_SetPan(
static HRESULT WINAPI PrimaryBufferImpl_GetPan( static HRESULT WINAPI PrimaryBufferImpl_GetPan(
LPDIRECTSOUNDBUFFER8 iface,LPLONG pan LPDIRECTSOUNDBUFFER8 iface,LPLONG pan
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
DWORD ampfactors; DWORD ampfactors;
DSVOLUMEPAN volpan; DSVOLUMEPAN volpan;
TRACE("(%p,%p)\n", iface, pan); TRACE("(%p,%p)\n", iface, pan);
@ -813,7 +813,7 @@ static HRESULT WINAPI PrimaryBufferImpl_GetPan(
static HRESULT WINAPI PrimaryBufferImpl_Unlock( static HRESULT WINAPI PrimaryBufferImpl_Unlock(
LPDIRECTSOUNDBUFFER8 iface,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2 LPDIRECTSOUNDBUFFER8 iface,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%p,%ld,%p,%ld)\n", iface, p1, x1, p2, x2); TRACE("(%p,%p,%ld,%p,%ld)\n", iface, p1, x1, p2, x2);
if (device->priolevel != DSSCL_WRITEPRIMARY) { if (device->priolevel != DSSCL_WRITEPRIMARY) {
@ -845,7 +845,7 @@ static HRESULT WINAPI PrimaryBufferImpl_Restore(
static HRESULT WINAPI PrimaryBufferImpl_GetFrequency( static HRESULT WINAPI PrimaryBufferImpl_GetFrequency(
LPDIRECTSOUNDBUFFER8 iface,LPDWORD freq LPDIRECTSOUNDBUFFER8 iface,LPDWORD freq
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%p)\n", iface, freq); TRACE("(%p,%p)\n", iface, freq);
if (freq == NULL) { if (freq == NULL) {
@ -915,7 +915,7 @@ static HRESULT WINAPI PrimaryBufferImpl_Initialize(
static HRESULT WINAPI PrimaryBufferImpl_GetCaps( static HRESULT WINAPI PrimaryBufferImpl_GetCaps(
LPDIRECTSOUNDBUFFER8 iface,LPDSBCAPS caps LPDIRECTSOUNDBUFFER8 iface,LPDSBCAPS caps
) { ) {
DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->dsound->device; DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
TRACE("(%p,%p)\n", iface, caps); TRACE("(%p,%p)\n", iface, caps);
if (caps == NULL) { if (caps == NULL) {
@ -948,7 +948,7 @@ static HRESULT WINAPI PrimaryBufferImpl_QueryInterface(
LPDIRECTSOUNDBUFFER8 iface,REFIID riid,LPVOID *ppobj LPDIRECTSOUNDBUFFER8 iface,REFIID riid,LPVOID *ppobj
) { ) {
PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface; PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
DirectSoundDevice *device = This->dsound->device; DirectSoundDevice *device = This->device;
TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppobj); TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppobj);
if (ppobj == NULL) { if (ppobj == NULL) {
@ -985,7 +985,7 @@ static HRESULT WINAPI PrimaryBufferImpl_QueryInterface(
if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) { if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
if (!device->listener) if (!device->listener)
IDirectSound3DListenerImpl_Create(This, &device->listener); IDirectSound3DListenerImpl_Create(device, &device->listener);
if (device->listener) { if (device->listener) {
*ppobj = device->listener; *ppobj = device->listener;
IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)*ppobj); IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)*ppobj);
@ -1034,16 +1034,16 @@ static const IDirectSoundBuffer8Vtbl dspbvt =
}; };
HRESULT PrimaryBufferImpl_Create( HRESULT PrimaryBufferImpl_Create(
IDirectSoundImpl *ds, DirectSoundDevice * device,
PrimaryBufferImpl **pdsb, PrimaryBufferImpl ** ppdsb,
LPCDSBUFFERDESC dsbd) LPCDSBUFFERDESC dsbd)
{ {
PrimaryBufferImpl *dsb; PrimaryBufferImpl *dsb;
TRACE("%p,%p,%p)\n",ds,pdsb,dsbd); TRACE("%p,%p,%p)\n",device,ppdsb,dsbd);
if (dsbd->lpwfxFormat) { if (dsbd->lpwfxFormat) {
WARN("invalid parameter: dsbd->lpwfxFormat != NULL\n"); WARN("invalid parameter: dsbd->lpwfxFormat != NULL\n");
*pdsb = NULL; *ppdsb = NULL;
return DSERR_INVALIDPARAM; return DSERR_INVALIDPARAM;
} }
@ -1051,23 +1051,24 @@ HRESULT PrimaryBufferImpl_Create(
if (dsb == NULL) { if (dsb == NULL) {
WARN("out of memory\n"); WARN("out of memory\n");
*pdsb = NULL; *ppdsb = NULL;
return DSERR_OUTOFMEMORY; return DSERR_OUTOFMEMORY;
} }
dsb->ref = 0; dsb->ref = 0;
dsb->dsound = ds; dsb->device = device;
dsb->lpVtbl = &dspbvt; dsb->lpVtbl = &dspbvt;
CopyMemory(&ds->device->dsbd, dsbd, sizeof(*dsbd)); CopyMemory(&device->dsbd, dsbd, sizeof(*dsbd));
TRACE("Created primary buffer at %p\n", dsb); TRACE("Created primary buffer at %p\n", dsb);
TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld," TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld,"
"bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n", "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
ds->device->pwfx->wFormatTag, ds->device->pwfx->nChannels, ds->device->pwfx->nSamplesPerSec, device->pwfx->wFormatTag, device->pwfx->nChannels,
ds->device->pwfx->nAvgBytesPerSec, ds->device->pwfx->nBlockAlign, device->pwfx->nSamplesPerSec, device->pwfx->nAvgBytesPerSec,
ds->device->pwfx->wBitsPerSample, ds->device->pwfx->cbSize); device->pwfx->nBlockAlign, device->pwfx->wBitsPerSample,
device->pwfx->cbSize);
*pdsb = dsb; *ppdsb = dsb;
return S_OK; return S_OK;
} }

4
dlls/dsound/propset.c
View File

@ -110,7 +110,7 @@ static HRESULT WINAPI IKsBufferPropertySetImpl_Get(
S(prop).Set = *guidPropSet; S(prop).Set = *guidPropSet;
S(prop).Id = dwPropID; S(prop).Id = dwPropID;
S(prop).Flags = 0; /* unused */ S(prop).Flags = 0; /* unused */
S(prop).InstanceId = (ULONG)This->dsb->dsound; S(prop).InstanceId = (ULONG)This->dsb->device;
hres = IDsDriverPropertySet_Get(ps, &prop, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned); hres = IDsDriverPropertySet_Get(ps, &prop, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned);
@ -146,7 +146,7 @@ static HRESULT WINAPI IKsBufferPropertySetImpl_Set(
S(prop).Set = *guidPropSet; S(prop).Set = *guidPropSet;
S(prop).Id = dwPropID; S(prop).Id = dwPropID;
S(prop).Flags = 0; /* unused */ S(prop).Flags = 0; /* unused */
S(prop).InstanceId = (ULONG)This->dsb->dsound; S(prop).InstanceId = (ULONG)This->dsb->device;
hres = IDsDriverPropertySet_Set(ps,&prop,pInstanceData,cbInstanceData,pPropData,cbPropData); hres = IDsDriverPropertySet_Set(ps,&prop,pInstanceData,cbInstanceData,pPropData,cbPropData);
IDsDriverPropertySet_Release(ps); IDsDriverPropertySet_Release(ps);

182
dlls/dsound/sound3d.c
View File

@ -207,7 +207,7 @@ void DSOUND_Calc3DBuffer(IDirectSoundBufferImpl *dsb)
case DS3DMODE_NORMAL: case DS3DMODE_NORMAL:
TRACE("Normal 3D processing mode\n"); TRACE("Normal 3D processing mode\n");
/* we need to calculate distance between buffer and listener*/ /* we need to calculate distance between buffer and listener*/
vDistance = VectorBetweenTwoPoints(&dsb->ds3db_ds3db.vPosition, &dsb->dsound->device->ds3dl.vPosition); vDistance = VectorBetweenTwoPoints(&dsb->ds3db_ds3db.vPosition, &dsb->device->ds3dl.vPosition);
flDistance = VectorMagnitude (&vDistance); flDistance = VectorMagnitude (&vDistance);
break; break;
case DS3DMODE_HEADRELATIVE: case DS3DMODE_HEADRELATIVE:
@ -277,16 +277,16 @@ void DSOUND_Calc3DBuffer(IDirectSoundBufferImpl *dsb)
dsb->volpan.lVolume = lVolume; dsb->volpan.lVolume = lVolume;
/* panning */ /* panning */
if (dsb->dsound->device->ds3dl.vPosition.x == dsb->ds3db_ds3db.vPosition.x && if (dsb->device->ds3dl.vPosition.x == dsb->ds3db_ds3db.vPosition.x &&
dsb->dsound->device->ds3dl.vPosition.y == dsb->ds3db_ds3db.vPosition.y && dsb->device->ds3dl.vPosition.y == dsb->ds3db_ds3db.vPosition.y &&
dsb->dsound->device->ds3dl.vPosition.z == dsb->ds3db_ds3db.vPosition.z) { dsb->device->ds3dl.vPosition.z == dsb->ds3db_ds3db.vPosition.z) {
dsb->volpan.lPan = 0; dsb->volpan.lPan = 0;
flAngle = 0.0; flAngle = 0.0;
} }
else else
{ {
vDistance = VectorBetweenTwoPoints(&dsb->dsound->device->ds3dl.vPosition, &dsb->ds3db_ds3db.vPosition); vDistance = VectorBetweenTwoPoints(&dsb->device->ds3dl.vPosition, &dsb->ds3db_ds3db.vPosition);
vLeft = VectorProduct(&dsb->dsound->device->ds3dl.vOrientFront, &dsb->dsound->device->ds3dl.vOrientTop); vLeft = VectorProduct(&dsb->device->ds3dl.vOrientFront, &dsb->device->ds3dl.vOrientTop);
flAngle = AngleBetweenVectorsRad(&vLeft, &vDistance); flAngle = AngleBetweenVectorsRad(&vLeft, &vDistance);
/* for now, we'll use "linear formula" (which is probably incorrect); if someone has it in book, correct it */ /* for now, we'll use "linear formula" (which is probably incorrect); if someone has it in book, correct it */
dsb->volpan.lPan = 10000*2*flAngle/M_PI - 10000; dsb->volpan.lPan = 10000*2*flAngle/M_PI - 10000;
@ -296,7 +296,7 @@ void DSOUND_Calc3DBuffer(IDirectSoundBufferImpl *dsb)
/* FIXME: Doppler Effect disabled since i have no idea which frequency to change and how to do it */ /* FIXME: Doppler Effect disabled since i have no idea which frequency to change and how to do it */
#if 0 #if 0
/* doppler shift*/ /* doppler shift*/
if ((VectorMagnitude(&ds3db.vVelocity) == 0) && (VectorMagnitude(&dsb->dsound->device->ds3dl.vVelocity) == 0)) if ((VectorMagnitude(&ds3db.vVelocity) == 0) && (VectorMagnitude(&dsb->device->ds3dl.vVelocity) == 0))
{ {
TRACE("doppler: Buffer and Listener don't have velocities\n"); TRACE("doppler: Buffer and Listener don't have velocities\n");
} }
@ -309,7 +309,7 @@ void DSOUND_Calc3DBuffer(IDirectSoundBufferImpl *dsb)
/* calculate length of ds3dl.vVelocity component which causes Doppler Effect /* calculate length of ds3dl.vVelocity component which causes Doppler Effect
NOTE: if listener moves TOWARDS the buffer, it's velocity component is POSITIVE NOTE: if listener moves TOWARDS the buffer, it's velocity component is POSITIVE
if listener moves AWAY from buffer, it's velocity component is NEGATIVE */ if listener moves AWAY from buffer, it's velocity component is NEGATIVE */
flListenerVel = ProjectVector(&dsb->dsound->device->ds3dl.vVelocity, &vDistance); flListenerVel = ProjectVector(&dsb->device->ds3dl.vVelocity, &vDistance);
/* formula taken from Gianicoli D.: Physics, 4th edition: */ /* formula taken from Gianicoli D.: Physics, 4th edition: */
/* FIXME: replace dsb->freq with appropriate frequency ! */ /* FIXME: replace dsb->freq with appropriate frequency ! */
flFreq = dsb->freq * ((DEFAULT_VELOCITY + flListenerVel)/(DEFAULT_VELOCITY + flBufferVel)); flFreq = dsb->freq * ((DEFAULT_VELOCITY + flListenerVel)/(DEFAULT_VELOCITY + flBufferVel));
@ -336,15 +336,15 @@ static void DSOUND_ChangeListener(IDirectSound3DListenerImpl *ds3dl)
{ {
int i; int i;
TRACE("(%p)\n",ds3dl); TRACE("(%p)\n",ds3dl);
for (i = 0; i < ds3dl->dsound->device->nrofbuffers; i++) for (i = 0; i < ds3dl->device->nrofbuffers; i++)
{ {
/* some buffers don't have 3d buffer (Ultima IX seems to /* some buffers don't have 3d buffer (Ultima IX seems to
crash without the following line) */ crash without the following line) */
if (ds3dl->dsound->device->buffers[i]->ds3db == NULL) if (ds3dl->device->buffers[i]->ds3db == NULL)
continue; continue;
if (ds3dl->dsound->device->buffers[i]->ds3db_need_recalc) if (ds3dl->device->buffers[i]->ds3db_need_recalc)
{ {
DSOUND_Mix3DBuffer(ds3dl->dsound->device->buffers[i]); DSOUND_Mix3DBuffer(ds3dl->device->buffers[i]);
} }
} }
} }
@ -786,10 +786,10 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_QueryInterface(
} }
if ( IsEqualGUID(riid, &IID_IDirectSoundBuffer) ) { if ( IsEqualGUID(riid, &IID_IDirectSoundBuffer) ) {
if (!This->dsound->device->primary) if (!This->device->primary)
PrimaryBufferImpl_Create(This->dsound, &(This->dsound->device->primary), &(This->dsound->device->dsbd)); PrimaryBufferImpl_Create(This->device, &(This->device->primary), &(This->device->dsbd));
if (This->dsound->device->primary) { if (This->device->primary) {
*ppobj = This->dsound->device->primary; *ppobj = This->device->primary;
IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)*ppobj); IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)*ppobj);
return S_OK; return S_OK;
} }
@ -814,7 +814,7 @@ static ULONG WINAPI IDirectSound3DListenerImpl_Release(LPDIRECTSOUND3DLISTENER i
TRACE("(%p) ref was %ld\n", This, ref + 1); TRACE("(%p) ref was %ld\n", This, ref + 1);
if (!ref) { if (!ref) {
This->dsound->device->listener = 0; This->device->listener = 0;
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
TRACE("(%p) released\n", This); TRACE("(%p) released\n", This);
} }
@ -840,7 +840,7 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_GetAllParameter(
} }
TRACE("returning: all parameters\n"); TRACE("returning: all parameters\n");
*lpDS3DL = This->dsound->device->ds3dl; *lpDS3DL = This->device->ds3dl;
return DS_OK; return DS_OK;
} }
@ -849,8 +849,8 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_GetDistanceFactor(
LPD3DVALUE lpfDistanceFactor) LPD3DVALUE lpfDistanceFactor)
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("returning: Distance Factor = %f\n", This->dsound->device->ds3dl.flDistanceFactor); TRACE("returning: Distance Factor = %f\n", This->device->ds3dl.flDistanceFactor);
*lpfDistanceFactor = This->dsound->device->ds3dl.flDistanceFactor; *lpfDistanceFactor = This->device->ds3dl.flDistanceFactor;
return DS_OK; return DS_OK;
} }
@ -859,8 +859,8 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_GetDopplerFactor(
LPD3DVALUE lpfDopplerFactor) LPD3DVALUE lpfDopplerFactor)
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("returning: Doppler Factor = %f\n", This->dsound->device->ds3dl.flDopplerFactor); TRACE("returning: Doppler Factor = %f\n", This->device->ds3dl.flDopplerFactor);
*lpfDopplerFactor = This->dsound->device->ds3dl.flDopplerFactor; *lpfDopplerFactor = This->device->ds3dl.flDopplerFactor;
return DS_OK; return DS_OK;
} }
@ -870,11 +870,11 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_GetOrientation(
LPD3DVECTOR lpvOrientTop) LPD3DVECTOR lpvOrientTop)
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("returning: OrientFront vector = (%f,%f,%f); OrientTop vector = (%f,%f,%f)\n", This->dsound->device->ds3dl.vOrientFront.x, \ TRACE("returning: OrientFront vector = (%f,%f,%f); OrientTop vector = (%f,%f,%f)\n", This->device->ds3dl.vOrientFront.x, \
This->dsound->device->ds3dl.vOrientFront.y, This->dsound->device->ds3dl.vOrientFront.z, This->dsound->device->ds3dl.vOrientTop.x, This->dsound->device->ds3dl.vOrientTop.y, \ This->device->ds3dl.vOrientFront.y, This->device->ds3dl.vOrientFront.z, This->device->ds3dl.vOrientTop.x, This->device->ds3dl.vOrientTop.y, \
This->dsound->device->ds3dl.vOrientTop.z); This->device->ds3dl.vOrientTop.z);
*lpvOrientFront = This->dsound->device->ds3dl.vOrientFront; *lpvOrientFront = This->device->ds3dl.vOrientFront;
*lpvOrientTop = This->dsound->device->ds3dl.vOrientTop; *lpvOrientTop = This->device->ds3dl.vOrientTop;
return DS_OK; return DS_OK;
} }
@ -883,8 +883,8 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_GetPosition(
LPD3DVECTOR lpvPosition) LPD3DVECTOR lpvPosition)
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("returning: Position vector = (%f,%f,%f)\n", This->dsound->device->ds3dl.vPosition.x, This->dsound->device->ds3dl.vPosition.y, This->dsound->device->ds3dl.vPosition.z); TRACE("returning: Position vector = (%f,%f,%f)\n", This->device->ds3dl.vPosition.x, This->device->ds3dl.vPosition.y, This->device->ds3dl.vPosition.z);
*lpvPosition = This->dsound->device->ds3dl.vPosition; *lpvPosition = This->device->ds3dl.vPosition;
return DS_OK; return DS_OK;
} }
@ -893,8 +893,8 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_GetRolloffFactor(
LPD3DVALUE lpfRolloffFactor) LPD3DVALUE lpfRolloffFactor)
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("returning: RolloffFactor = %f\n", This->dsound->device->ds3dl.flRolloffFactor); TRACE("returning: RolloffFactor = %f\n", This->device->ds3dl.flRolloffFactor);
*lpfRolloffFactor = This->dsound->device->ds3dl.flRolloffFactor; *lpfRolloffFactor = This->device->ds3dl.flRolloffFactor;
return DS_OK; return DS_OK;
} }
@ -903,8 +903,8 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_GetVelocity(
LPD3DVECTOR lpvVelocity) LPD3DVECTOR lpvVelocity)
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("returning: Velocity vector = (%f,%f,%f)\n", This->dsound->device->ds3dl.vVelocity.x, This->dsound->device->ds3dl.vVelocity.y, This->dsound->device->ds3dl.vVelocity.z); TRACE("returning: Velocity vector = (%f,%f,%f)\n", This->device->ds3dl.vVelocity.x, This->device->ds3dl.vVelocity.y, This->device->ds3dl.vVelocity.z);
*lpvVelocity = This->dsound->device->ds3dl.vVelocity; *lpvVelocity = This->device->ds3dl.vVelocity;
return DS_OK; return DS_OK;
} }
@ -915,13 +915,13 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_SetAllParameters(
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("setting: all parameters; dwApply = %ld\n", dwApply); TRACE("setting: all parameters; dwApply = %ld\n", dwApply);
This->dsound->device->ds3dl = *lpcDS3DL; This->device->ds3dl = *lpcDS3DL;
if (dwApply == DS3D_IMMEDIATE) if (dwApply == DS3D_IMMEDIATE)
{ {
This->dsound->device->ds3dl_need_recalc = FALSE; This->device->ds3dl_need_recalc = FALSE;
DSOUND_ChangeListener(This); DSOUND_ChangeListener(This);
} }
This->dsound->device->ds3dl_need_recalc = TRUE; This->device->ds3dl_need_recalc = TRUE;
return DS_OK; return DS_OK;
} }
@ -932,13 +932,13 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_SetDistanceFactor(
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("setting: Distance Factor = %f; dwApply = %ld\n", fDistanceFactor, dwApply); TRACE("setting: Distance Factor = %f; dwApply = %ld\n", fDistanceFactor, dwApply);
This->dsound->device->ds3dl.flDistanceFactor = fDistanceFactor; This->device->ds3dl.flDistanceFactor = fDistanceFactor;
if (dwApply == DS3D_IMMEDIATE) if (dwApply == DS3D_IMMEDIATE)
{ {
This->dsound->device->ds3dl_need_recalc = FALSE; This->device->ds3dl_need_recalc = FALSE;
DSOUND_ChangeListener(This); DSOUND_ChangeListener(This);
} }
This->dsound->device->ds3dl_need_recalc = TRUE; This->device->ds3dl_need_recalc = TRUE;
return DS_OK; return DS_OK;
} }
@ -949,13 +949,13 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_SetDopplerFactor(
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("setting: Doppler Factor = %f; dwApply = %ld\n", fDopplerFactor, dwApply); TRACE("setting: Doppler Factor = %f; dwApply = %ld\n", fDopplerFactor, dwApply);
This->dsound->device->ds3dl.flDopplerFactor = fDopplerFactor; This->device->ds3dl.flDopplerFactor = fDopplerFactor;
if (dwApply == DS3D_IMMEDIATE) if (dwApply == DS3D_IMMEDIATE)
{ {
This->dsound->device->ds3dl_need_recalc = FALSE; This->device->ds3dl_need_recalc = FALSE;
DSOUND_ChangeListener(This); DSOUND_ChangeListener(This);
} }
This->dsound->device->ds3dl_need_recalc = TRUE; This->device->ds3dl_need_recalc = TRUE;
return DS_OK; return DS_OK;
} }
@ -968,18 +968,18 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_SetOrientation(
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("setting: Front vector = (%f,%f,%f); Top vector = (%f,%f,%f); dwApply = %ld\n", \ TRACE("setting: Front vector = (%f,%f,%f); Top vector = (%f,%f,%f); dwApply = %ld\n", \
xFront, yFront, zFront, xTop, yTop, zTop, dwApply); xFront, yFront, zFront, xTop, yTop, zTop, dwApply);
This->dsound->device->ds3dl.vOrientFront.x = xFront; This->device->ds3dl.vOrientFront.x = xFront;
This->dsound->device->ds3dl.vOrientFront.y = yFront; This->device->ds3dl.vOrientFront.y = yFront;
This->dsound->device->ds3dl.vOrientFront.z = zFront; This->device->ds3dl.vOrientFront.z = zFront;
This->dsound->device->ds3dl.vOrientTop.x = xTop; This->device->ds3dl.vOrientTop.x = xTop;
This->dsound->device->ds3dl.vOrientTop.y = yTop; This->device->ds3dl.vOrientTop.y = yTop;
This->dsound->device->ds3dl.vOrientTop.z = zTop; This->device->ds3dl.vOrientTop.z = zTop;
if (dwApply == DS3D_IMMEDIATE) if (dwApply == DS3D_IMMEDIATE)
{ {
This->dsound->device->ds3dl_need_recalc = FALSE; This->device->ds3dl_need_recalc = FALSE;
DSOUND_ChangeListener(This); DSOUND_ChangeListener(This);
} }
This->dsound->device->ds3dl_need_recalc = TRUE; This->device->ds3dl_need_recalc = TRUE;
return DS_OK; return DS_OK;
} }
@ -990,15 +990,15 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_SetPosition(
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("setting: Position vector = (%f,%f,%f); dwApply = %ld\n", x, y, z, dwApply); TRACE("setting: Position vector = (%f,%f,%f); dwApply = %ld\n", x, y, z, dwApply);
This->dsound->device->ds3dl.vPosition.x = x; This->device->ds3dl.vPosition.x = x;
This->dsound->device->ds3dl.vPosition.y = y; This->device->ds3dl.vPosition.y = y;
This->dsound->device->ds3dl.vPosition.z = z; This->device->ds3dl.vPosition.z = z;
if (dwApply == DS3D_IMMEDIATE) if (dwApply == DS3D_IMMEDIATE)
{ {
This->dsound->device->ds3dl_need_recalc = FALSE; This->device->ds3dl_need_recalc = FALSE;
DSOUND_ChangeListener(This); DSOUND_ChangeListener(This);
} }
This->dsound->device->ds3dl_need_recalc = TRUE; This->device->ds3dl_need_recalc = TRUE;
return DS_OK; return DS_OK;
} }
@ -1009,13 +1009,13 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_SetRolloffFactor(
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("setting: Rolloff Factor = %f; dwApply = %ld\n", fRolloffFactor, dwApply); TRACE("setting: Rolloff Factor = %f; dwApply = %ld\n", fRolloffFactor, dwApply);
This->dsound->device->ds3dl.flRolloffFactor = fRolloffFactor; This->device->ds3dl.flRolloffFactor = fRolloffFactor;
if (dwApply == DS3D_IMMEDIATE) if (dwApply == DS3D_IMMEDIATE)
{ {
This->dsound->device->ds3dl_need_recalc = FALSE; This->device->ds3dl_need_recalc = FALSE;
DSOUND_ChangeListener(This); DSOUND_ChangeListener(This);
} }
This->dsound->device->ds3dl_need_recalc = TRUE; This->device->ds3dl_need_recalc = TRUE;
return DS_OK; return DS_OK;
} }
@ -1026,15 +1026,15 @@ static HRESULT WINAPI IDirectSound3DListenerImpl_SetVelocity(
{ {
IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface; IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
TRACE("setting: Velocity vector = (%f,%f,%f); dwApply = %ld\n", x, y, z, dwApply); TRACE("setting: Velocity vector = (%f,%f,%f); dwApply = %ld\n", x, y, z, dwApply);
This->dsound->device->ds3dl.vVelocity.x = x; This->device->ds3dl.vVelocity.x = x;
This->dsound->device->ds3dl.vVelocity.y = y; This->device->ds3dl.vVelocity.y = y;
This->dsound->device->ds3dl.vVelocity.z = z; This->device->ds3dl.vVelocity.z = z;
if (dwApply == DS3D_IMMEDIATE) if (dwApply == DS3D_IMMEDIATE)
{ {
This->dsound->device->ds3dl_need_recalc = FALSE; This->device->ds3dl_need_recalc = FALSE;
DSOUND_ChangeListener(This); DSOUND_ChangeListener(This);
} }
This->dsound->device->ds3dl_need_recalc = TRUE; This->device->ds3dl_need_recalc = TRUE;
return DS_OK; return DS_OK;
} }
@ -1072,44 +1072,44 @@ static const IDirectSound3DListenerVtbl ds3dlvt =
}; };
HRESULT IDirectSound3DListenerImpl_Create( HRESULT IDirectSound3DListenerImpl_Create(
PrimaryBufferImpl *This, DirectSoundDevice * device,
IDirectSound3DListenerImpl **pdsl) IDirectSound3DListenerImpl ** ppdsl)
{ {
IDirectSound3DListenerImpl *dsl; IDirectSound3DListenerImpl *pdsl;
TRACE("(%p,%p)\n",This,pdsl); TRACE("(%p,%p)\n",device,ppdsl);
dsl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsl)); pdsl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*pdsl));
if (dsl == NULL) { if (pdsl == NULL) {
WARN("out of memory\n"); WARN("out of memory\n");
*pdsl = 0; *ppdsl = 0;
return DSERR_OUTOFMEMORY; return DSERR_OUTOFMEMORY;
} }
dsl->ref = 0; pdsl->ref = 0;
dsl->lpVtbl = &ds3dlvt; pdsl->lpVtbl = &ds3dlvt;
dsl->dsound = This->dsound; pdsl->device = device;
dsl->dsound->device->ds3dl.dwSize = sizeof(DS3DLISTENER); pdsl->device->ds3dl.dwSize = sizeof(DS3DLISTENER);
dsl->dsound->device->ds3dl.vPosition.x = 0.0; pdsl->device->ds3dl.vPosition.x = 0.0;
dsl->dsound->device->ds3dl.vPosition.y = 0.0; pdsl->device->ds3dl.vPosition.y = 0.0;
dsl->dsound->device->ds3dl.vPosition.z = 0.0; pdsl->device->ds3dl.vPosition.z = 0.0;
dsl->dsound->device->ds3dl.vVelocity.x = 0.0; pdsl->device->ds3dl.vVelocity.x = 0.0;
dsl->dsound->device->ds3dl.vVelocity.y = 0.0; pdsl->device->ds3dl.vVelocity.y = 0.0;
dsl->dsound->device->ds3dl.vVelocity.z = 0.0; pdsl->device->ds3dl.vVelocity.z = 0.0;
dsl->dsound->device->ds3dl.vOrientFront.x = 0.0; pdsl->device->ds3dl.vOrientFront.x = 0.0;
dsl->dsound->device->ds3dl.vOrientFront.y = 0.0; pdsl->device->ds3dl.vOrientFront.y = 0.0;
dsl->dsound->device->ds3dl.vOrientFront.z = 1.0; pdsl->device->ds3dl.vOrientFront.z = 1.0;
dsl->dsound->device->ds3dl.vOrientTop.x = 0.0; pdsl->device->ds3dl.vOrientTop.x = 0.0;
dsl->dsound->device->ds3dl.vOrientTop.y = 1.0; pdsl->device->ds3dl.vOrientTop.y = 1.0;
dsl->dsound->device->ds3dl.vOrientTop.z = 0.0; pdsl->device->ds3dl.vOrientTop.z = 0.0;
dsl->dsound->device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR; pdsl->device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
dsl->dsound->device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR; pdsl->device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
dsl->dsound->device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR; pdsl->device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
dsl->dsound->device->ds3dl_need_recalc = TRUE; pdsl->device->ds3dl_need_recalc = TRUE;
*pdsl = dsl; *ppdsl = pdsl;
return S_OK; return S_OK;
} }