/* DirectSound * * Copyright 1998 Marcus Meissner * Copyright 1998 Rob Riggs * Copyright 2000-2002 TransGaming Technologies, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * * TODO: * When PrimarySetFormat (via ReopenDevice or PrimaryOpen) fails, * it leaves dsound in unusable (not really open) state. */ #include <stdarg.h> #define COBJMACROS #define NONAMELESSUNION #include "windef.h" #include "winbase.h" #include "winuser.h" #include "mmsystem.h" #include "winternl.h" #include "mmddk.h" #include "wine/debug.h" #include "dsound.h" #include "dsound_private.h" WINE_DEFAULT_DEBUG_CHANNEL(dsound); static DWORD speaker_config_to_channel_mask(DWORD speaker_config) { switch (DSSPEAKER_CONFIG(speaker_config)) { case DSSPEAKER_MONO: return SPEAKER_FRONT_LEFT; case DSSPEAKER_STEREO: case DSSPEAKER_HEADPHONE: return SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; case DSSPEAKER_QUAD: return SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; case DSSPEAKER_5POINT1_BACK: return SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; } WARN("unknown speaker_config %u\n", speaker_config); return SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; } static DWORD DSOUND_FindSpeakerConfig(IMMDevice *mmdevice, int channels) { IPropertyStore *store; HRESULT hr; PROPVARIANT pv; ULONG phys_speakers; const DWORD def = DSSPEAKER_COMBINED(DSSPEAKER_STEREO, DSSPEAKER_GEOMETRY_WIDE); hr = IMMDevice_OpenPropertyStore(mmdevice, STGM_READ, &store); if (FAILED(hr)) { WARN("IMMDevice_OpenPropertyStore failed: %08x\n", hr); return def; } hr = IPropertyStore_GetValue(store, &PKEY_AudioEndpoint_PhysicalSpeakers, &pv); if (FAILED(hr)) { WARN("IPropertyStore_GetValue failed: %08x\n", hr); IPropertyStore_Release(store); return def; } if (pv.vt != VT_UI4) { WARN("PKEY_AudioEndpoint_PhysicalSpeakers is not a ULONG: 0x%x\n", pv.vt); PropVariantClear(&pv); IPropertyStore_Release(store); return def; } phys_speakers = pv.u.ulVal; PropVariantClear(&pv); IPropertyStore_Release(store); if ((channels >= 6 || channels == 0) && (phys_speakers & KSAUDIO_SPEAKER_5POINT1) == KSAUDIO_SPEAKER_5POINT1) return DSSPEAKER_5POINT1_BACK; else if ((channels >= 6 || channels == 0) && (phys_speakers & KSAUDIO_SPEAKER_5POINT1_SURROUND) == KSAUDIO_SPEAKER_5POINT1_SURROUND) return DSSPEAKER_5POINT1_SURROUND; else if ((channels >= 4 || channels == 0) && (phys_speakers & KSAUDIO_SPEAKER_QUAD) == KSAUDIO_SPEAKER_QUAD) return DSSPEAKER_QUAD; else if ((channels >= 2 || channels == 0) && (phys_speakers & KSAUDIO_SPEAKER_STEREO) == KSAUDIO_SPEAKER_STEREO) return DSSPEAKER_COMBINED(DSSPEAKER_STEREO, DSSPEAKER_GEOMETRY_WIDE); else if ((phys_speakers & KSAUDIO_SPEAKER_MONO) == KSAUDIO_SPEAKER_MONO) return DSSPEAKER_MONO; return def; } static HRESULT DSOUND_WaveFormat(DirectSoundDevice *device, IAudioClient *client, BOOL forcewave, WAVEFORMATEX **wfx) { WAVEFORMATEXTENSIBLE *retwfe = NULL; WAVEFORMATEX *w; HRESULT hr; if (!forcewave) { WAVEFORMATEXTENSIBLE *mixwfe; hr = IAudioClient_GetMixFormat(client, (WAVEFORMATEX**)&mixwfe); if (FAILED(hr)) return hr; if (mixwfe->Format.nChannels < device->num_speakers) { device->speaker_config = DSOUND_FindSpeakerConfig(device->mmdevice, mixwfe->Format.nChannels); DSOUND_ParseSpeakerConfig(device); } else if (mixwfe->Format.nChannels > device->num_speakers) { mixwfe->Format.nChannels = device->num_speakers; mixwfe->Format.nBlockAlign = mixwfe->Format.nChannels * mixwfe->Format.wBitsPerSample / 8; mixwfe->Format.nAvgBytesPerSec = mixwfe->Format.nSamplesPerSec * mixwfe->Format.nBlockAlign; mixwfe->dwChannelMask = speaker_config_to_channel_mask(device->speaker_config); } if (!IsEqualGUID(&mixwfe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) { WAVEFORMATEXTENSIBLE testwfe = *mixwfe; testwfe.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT; testwfe.Samples.wValidBitsPerSample = testwfe.Format.wBitsPerSample = 32; testwfe.Format.nBlockAlign = testwfe.Format.nChannels * testwfe.Format.wBitsPerSample / 8; testwfe.Format.nAvgBytesPerSec = testwfe.Format.nSamplesPerSec * testwfe.Format.nBlockAlign; if (FAILED(IAudioClient_IsFormatSupported(client, AUDCLNT_SHAREMODE_SHARED, &testwfe.Format, (WAVEFORMATEX**)&retwfe))) w = DSOUND_CopyFormat(&mixwfe->Format); else if (retwfe) w = DSOUND_CopyFormat(&retwfe->Format); else w = DSOUND_CopyFormat(&testwfe.Format); CoTaskMemFree(retwfe); retwfe = NULL; } else w = DSOUND_CopyFormat(&mixwfe->Format); CoTaskMemFree(mixwfe); } else if (device->primary_pwfx->wFormatTag == WAVE_FORMAT_PCM || device->primary_pwfx->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) { WAVEFORMATEX *wi = device->primary_pwfx; WAVEFORMATEXTENSIBLE *wfe; /* Convert to WAVEFORMATEXTENSIBLE */ w = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEFORMATEXTENSIBLE)); wfe = (WAVEFORMATEXTENSIBLE*)w; if (!wfe) return DSERR_OUTOFMEMORY; wfe->Format = *wi; w->wFormatTag = WAVE_FORMAT_EXTENSIBLE; w->cbSize = sizeof(*wfe) - sizeof(*w); w->nBlockAlign = w->nChannels * w->wBitsPerSample / 8; w->nAvgBytesPerSec = w->nSamplesPerSec * w->nBlockAlign; wfe->dwChannelMask = 0; if (wi->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) { w->wBitsPerSample = 32; wfe->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT; } else wfe->SubFormat = KSDATAFORMAT_SUBTYPE_PCM; wfe->Samples.wValidBitsPerSample = w->wBitsPerSample; } else w = DSOUND_CopyFormat(device->primary_pwfx); if (!w) return DSERR_OUTOFMEMORY; hr = IAudioClient_IsFormatSupported(client, AUDCLNT_SHAREMODE_SHARED, w, (WAVEFORMATEX**)&retwfe); if (retwfe) { memcpy(w, retwfe, sizeof(WAVEFORMATEX) + retwfe->Format.cbSize); CoTaskMemFree(retwfe); } if (FAILED(hr)) { WARN("IsFormatSupported failed: %08x\n", hr); HeapFree(GetProcessHeap(), 0, w); return hr; } *wfx = w; return S_OK; } static void DSOUND_ReleaseDevice(DirectSoundDevice *device) { if(device->client){ IAudioClient_Release(device->client); device->client = NULL; } if(device->render){ IAudioRenderClient_Release(device->render); device->render = NULL; } if(device->volume){ IAudioStreamVolume_Release(device->volume); device->volume = NULL; } if (device->pad) { device->playpos += device->pad; device->playpos %= device->buflen; device->pad = 0; } } static HRESULT DSOUND_PrimaryOpen(DirectSoundDevice *device, WAVEFORMATEX *wfx, DWORD frames, BOOL forcewave) { IDirectSoundBufferImpl** dsb = device->buffers; LPBYTE newbuf; DWORD new_buflen; BOOL mixfloat = FALSE; int i; TRACE("(%p)\n", device); new_buflen = device->buflen; new_buflen -= new_buflen % wfx->nBlockAlign; if (wfx->wFormatTag == WAVE_FORMAT_IEEE_FLOAT || (wfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE && IsEqualGUID(&((WAVEFORMATEXTENSIBLE*)wfx)->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))) mixfloat = TRUE; /* reallocate emulated primary buffer */ if (forcewave || !mixfloat) { if (!forcewave) new_buflen = frames * wfx->nChannels * sizeof(float); if (device->buffer) newbuf = HeapReAlloc(GetProcessHeap(), 0, device->buffer, new_buflen); else newbuf = HeapAlloc(GetProcessHeap(), 0, new_buflen); if (!newbuf) { ERR("failed to allocate primary buffer\n"); return DSERR_OUTOFMEMORY; } FillMemory(newbuf, new_buflen, (wfx->wBitsPerSample == 8) ? 128 : 0); } else { HeapFree(GetProcessHeap(), 0, device->buffer); newbuf = NULL; } device->buffer = newbuf; device->buflen = new_buflen; HeapFree(GetProcessHeap(), 0, device->pwfx); device->pwfx = wfx; device->writelead = (wfx->nSamplesPerSec / 100) * wfx->nBlockAlign; TRACE("buflen: %u, frames %u\n", device->buflen, frames); if (!mixfloat) device->normfunction = normfunctions[wfx->wBitsPerSample/8 - 1]; else device->normfunction = NULL; device->playpos = 0; for (i = 0; i < device->nrofbuffers; i++) { RtlAcquireResourceExclusive(&dsb[i]->lock, TRUE); DSOUND_RecalcFormat(dsb[i]); RtlReleaseResource(&dsb[i]->lock); } return DS_OK; } HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave) { HRESULT hres; REFERENCE_TIME period; UINT32 acbuf_frames, aclen_frames; DWORD period_ms; IAudioClient *client = NULL; IAudioRenderClient *render = NULL; IAudioStreamVolume *volume = NULL; DWORD frag_frames; WAVEFORMATEX *wfx = NULL; DWORD oldspeakerconfig = device->speaker_config; TRACE("(%p, %d)\n", device, forcewave); hres = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, (void **)&client); if(FAILED(hres)){ WARN("Activate failed: %08x\n", hres); return hres; } hres = DSOUND_WaveFormat(device, client, forcewave, &wfx); if (FAILED(hres)) { IAudioClient_Release(client); return hres; } hres = IAudioClient_Initialize(client, AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST | AUDCLNT_STREAMFLAGS_EVENTCALLBACK, 800000, 0, wfx, NULL); if(FAILED(hres)){ IAudioClient_Release(client); ERR("Initialize failed: %08x\n", hres); return hres; } IAudioClient_SetEventHandle(client, device->sleepev); hres = IAudioClient_GetService(client, &IID_IAudioRenderClient, (void**)&render); if(FAILED(hres)) goto err_service; hres = IAudioClient_GetService(client, &IID_IAudioStreamVolume, (void**)&volume); if(FAILED(hres)) goto err_service; /* Now kick off the timer so the event fires periodically */ hres = IAudioClient_Start(client); if (FAILED(hres)) { WARN("Start failed with %08x\n", hres); goto err; } hres = IAudioClient_GetStreamLatency(client, &period); if (FAILED(hres)) { WARN("GetStreamLatency failed with %08x\n", hres); goto err; } hres = IAudioClient_GetBufferSize(client, &acbuf_frames); if (FAILED(hres)) { WARN("GetBufferSize failed with %08x\n", hres); goto err; } period_ms = (period + 9999) / 10000; frag_frames = MulDiv(wfx->nSamplesPerSec, period, 10000000); aclen_frames = min(acbuf_frames, 3 * frag_frames); TRACE("period %u ms frag_frames %u buf_frames %u\n", period_ms, frag_frames, aclen_frames); hres = DSOUND_PrimaryOpen(device, wfx, aclen_frames, forcewave); if(FAILED(hres)) goto err; DSOUND_ReleaseDevice(device); device->client = client; device->render = render; device->volume = volume; device->frag_frames = frag_frames; device->ac_frames = aclen_frames; if (period_ms < 3) device->sleeptime = 5; else device->sleeptime = period_ms * 5 / 2; return S_OK; err_service: WARN("GetService failed: %08x\n", hres); err: device->speaker_config = oldspeakerconfig; DSOUND_ParseSpeakerConfig(device); if (volume) IAudioStreamVolume_Release(volume); if (render) IAudioRenderClient_Release(render); IAudioClient_Release(client); HeapFree(GetProcessHeap(), 0, wfx); return hres; } HRESULT DSOUND_PrimaryDestroy(DirectSoundDevice *device) { TRACE("(%p)\n", device); /* **** */ EnterCriticalSection(&(device->mixlock)); if(device->primary && (device->primary->ref || device->primary->numIfaces)) WARN("Destroying primary buffer while references held (%u %u)\n", device->primary->ref, device->primary->numIfaces); HeapFree(GetProcessHeap(), 0, device->primary); device->primary = NULL; HeapFree(GetProcessHeap(),0,device->primary_pwfx); HeapFree(GetProcessHeap(),0,device->pwfx); device->pwfx=NULL; LeaveCriticalSection(&(device->mixlock)); /* **** */ return DS_OK; } WAVEFORMATEX *DSOUND_CopyFormat(const WAVEFORMATEX *wfex) { WAVEFORMATEX *pwfx; if(wfex->wFormatTag == WAVE_FORMAT_PCM){ pwfx = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEFORMATEX)); if (!pwfx) return NULL; CopyMemory(pwfx, wfex, sizeof(PCMWAVEFORMAT)); pwfx->cbSize = 0; }else{ pwfx = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEFORMATEX) + wfex->cbSize); if (!pwfx) return NULL; CopyMemory(pwfx, wfex, sizeof(WAVEFORMATEX) + wfex->cbSize); } if(pwfx->wFormatTag == WAVE_FORMAT_PCM || (pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE && IsEqualGUID(&((const WAVEFORMATEXTENSIBLE*)pwfx)->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) pwfx->nBlockAlign = (pwfx->nChannels * pwfx->wBitsPerSample) / 8; return pwfx; } HRESULT primarybuffer_SetFormat(DirectSoundDevice *device, LPCWAVEFORMATEX passed_fmt) { HRESULT err = S_OK; WAVEFORMATEX *old_fmt; WAVEFORMATEXTENSIBLE *fmtex, *passed_fmtex = (WAVEFORMATEXTENSIBLE*)passed_fmt; TRACE("(%p,%p)\n", device, passed_fmt); if (device->priolevel == DSSCL_NORMAL) { WARN("failed priority check!\n"); return DSERR_PRIOLEVELNEEDED; } /* Let's be pedantic! */ if (passed_fmt == NULL) { WARN("invalid parameter: passed_fmt==NULL!\n"); return DSERR_INVALIDPARAM; } TRACE("(formattag=0x%04x,chans=%d,samplerate=%d," "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n", passed_fmt->wFormatTag, passed_fmt->nChannels, passed_fmt->nSamplesPerSec, passed_fmt->nAvgBytesPerSec, passed_fmt->nBlockAlign, passed_fmt->wBitsPerSample, passed_fmt->cbSize); if(passed_fmt->wBitsPerSample < 8 || passed_fmt->wBitsPerSample % 8 != 0 || passed_fmt->nChannels == 0 || passed_fmt->nSamplesPerSec == 0 || passed_fmt->nAvgBytesPerSec == 0 || passed_fmt->nBlockAlign != passed_fmt->nChannels * passed_fmt->wBitsPerSample / 8) return DSERR_INVALIDPARAM; if(passed_fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){ if(passed_fmtex->Samples.wValidBitsPerSample > passed_fmtex->Format.wBitsPerSample) return DSERR_INVALIDPARAM; } /* **** */ RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE); EnterCriticalSection(&(device->mixlock)); if (device->priolevel == DSSCL_WRITEPRIMARY) { old_fmt = device->primary_pwfx; device->primary_pwfx = DSOUND_CopyFormat(passed_fmt); fmtex = (WAVEFORMATEXTENSIBLE *)device->primary_pwfx; if (device->primary_pwfx == NULL) { err = DSERR_OUTOFMEMORY; goto out; } if (fmtex->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE && fmtex->Samples.wValidBitsPerSample == 0) { TRACE("Correcting 0 valid bits per sample\n"); fmtex->Samples.wValidBitsPerSample = fmtex->Format.wBitsPerSample; } err = DSOUND_ReopenDevice(device, TRUE); if (FAILED(err)) { ERR("No formats could be opened\n"); HeapFree(GetProcessHeap(), 0, device->primary_pwfx); device->primary_pwfx = old_fmt; } else HeapFree(GetProcessHeap(), 0, old_fmt); } else { WAVEFORMATEX *wfx = DSOUND_CopyFormat(passed_fmt); if (wfx) { HeapFree(GetProcessHeap(), 0, device->primary_pwfx); device->primary_pwfx = wfx; } else err = DSERR_OUTOFMEMORY; } out: LeaveCriticalSection(&(device->mixlock)); RtlReleaseResource(&(device->buffer_list_lock)); /* **** */ return err; } /******************************************************************************* * PrimaryBuffer */ static inline IDirectSoundBufferImpl *impl_from_IDirectSoundBuffer8(IDirectSoundBuffer8 *iface) { /* IDirectSoundBuffer and IDirectSoundBuffer8 use the same iface. */ return CONTAINING_RECORD(iface, IDirectSoundBufferImpl, IDirectSoundBuffer8_iface); } /* This sets this format for the primary buffer only */ static HRESULT WINAPI PrimaryBufferImpl_SetFormat(IDirectSoundBuffer8 *iface, const WAVEFORMATEX *wfex) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); TRACE("(%p,%p)\n", iface, wfex); return primarybuffer_SetFormat(This->device, wfex); } static HRESULT WINAPI PrimaryBufferImpl_SetVolume(IDirectSoundBuffer8 *iface, LONG vol) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; HRESULT hr; float fvol; int i; TRACE("(%p,%d)\n", iface, vol); if (!(This->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) { WARN("control unavailable\n"); return DSERR_CONTROLUNAVAIL; } if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN)) { WARN("invalid parameter: vol = %d\n", vol); return DSERR_INVALIDPARAM; } /* **** */ EnterCriticalSection(&device->mixlock); for (i = 0; i < DS_MAX_CHANNELS; i++) { if (device->pwfx->nChannels > i){ hr = IAudioStreamVolume_GetChannelVolume(device->volume, i, &fvol); if (FAILED(hr)){ LeaveCriticalSection(&device->mixlock); WARN("GetChannelVolume failed: %08x\n", hr); return hr; } } else fvol=1.0f; device->volpan.dwTotalAmpFactor[i]=((UINT16)(fvol * (DWORD)0xFFFF)); } DSOUND_AmpFactorToVolPan(&device->volpan); if (vol != device->volpan.lVolume) { device->volpan.lVolume=vol; DSOUND_RecalcVolPan(&device->volpan); for (i = 0; i < DS_MAX_CHANNELS; i++) { if (device->pwfx->nChannels > i){ fvol = (float)((DWORD)(device->volpan.dwTotalAmpFactor[i] & 0xFFFF) / (float)0xFFFF); hr = IAudioStreamVolume_SetChannelVolume(device->volume, i, fvol); if (FAILED(hr)){ LeaveCriticalSection(&device->mixlock); WARN("SetChannelVolume failed: %08x\n", hr); return hr; } } } } LeaveCriticalSection(&(device->mixlock)); /* **** */ return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_GetVolume(IDirectSoundBuffer8 *iface, LONG *vol) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; float fvol; HRESULT hr; int i; TRACE("(%p,%p)\n", iface, vol); if (!(This->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) { WARN("control unavailable\n"); return DSERR_CONTROLUNAVAIL; } if (vol == NULL) { WARN("invalid parameter: vol = NULL\n"); return DSERR_INVALIDPARAM; } EnterCriticalSection(&device->mixlock); for (i = 0; i < DS_MAX_CHANNELS; i++) { if (device->pwfx->nChannels > i){ hr = IAudioStreamVolume_GetChannelVolume(device->volume, i, &fvol); if (FAILED(hr)){ LeaveCriticalSection(&device->mixlock); WARN("GetChannelVolume failed: %08x\n", hr); return hr; } } else fvol = 1; device->volpan.dwTotalAmpFactor[i] = ((UINT16)(fvol * (DWORD)0xFFFF)); } DSOUND_AmpFactorToVolPan(&device->volpan); *vol = device->volpan.lVolume; LeaveCriticalSection(&device->mixlock); return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_SetFrequency(IDirectSoundBuffer8 *iface, DWORD freq) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); TRACE("(%p,%d)\n",This,freq); /* You cannot set the frequency of the primary buffer */ WARN("control unavailable\n"); return DSERR_CONTROLUNAVAIL; } static HRESULT WINAPI PrimaryBufferImpl_Play(IDirectSoundBuffer8 *iface, DWORD reserved1, DWORD reserved2, DWORD flags) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%08x,%08x,%08x)\n", iface, reserved1, reserved2, flags); if (!(flags & DSBPLAY_LOOPING)) { WARN("invalid parameter: flags = %08x\n", flags); return DSERR_INVALIDPARAM; } device->stopped = 0; return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_Stop(IDirectSoundBuffer8 *iface) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p)\n", iface); device->stopped = 1; return DS_OK; } static ULONG WINAPI PrimaryBufferImpl_AddRef(IDirectSoundBuffer8 *iface) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); ULONG ref = InterlockedIncrement(&(This->ref)); TRACE("(%p) ref was %d\n", This, ref - 1); if(ref == 1) InterlockedIncrement(&This->numIfaces); return ref; } /* Decreases *out by 1 to no less than 0. * Returns the new value of *out. */ LONG capped_refcount_dec(LONG *out) { LONG ref, oldref; do { ref = *out; if(!ref) return 0; oldref = InterlockedCompareExchange(out, ref - 1, ref); } while(oldref != ref); return ref - 1; } static ULONG WINAPI PrimaryBufferImpl_Release(IDirectSoundBuffer8 *iface) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); ULONG ref; ref = capped_refcount_dec(&This->ref); if(!ref) capped_refcount_dec(&This->numIfaces); TRACE("(%p) primary ref is now %d\n", This, ref); return ref; } static HRESULT WINAPI PrimaryBufferImpl_GetCurrentPosition(IDirectSoundBuffer8 *iface, DWORD *playpos, DWORD *writepos) { HRESULT hres = DS_OK; UINT32 pad = 0; UINT32 mixpos; IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%p,%p)\n", iface, playpos, writepos); /* **** */ EnterCriticalSection(&(device->mixlock)); if (device->client) hres = IAudioClient_GetCurrentPadding(device->client, &pad); if (hres != DS_OK) { WARN("IAudioClient_GetCurrentPadding failed\n"); LeaveCriticalSection(&(device->mixlock)); return hres; } mixpos = (device->playpos + pad * device->pwfx->nBlockAlign) % device->buflen; if (playpos) *playpos = mixpos; if (writepos) { *writepos = mixpos; if (!device->stopped) { /* apply the documented 10ms lead to writepos */ *writepos += device->writelead; *writepos %= device->buflen; } } LeaveCriticalSection(&(device->mixlock)); /* **** */ TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:0, writepos?*writepos:0, device, GetTickCount()); return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_GetStatus(IDirectSoundBuffer8 *iface, DWORD *status) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%p)\n", iface, status); if (status == NULL) { WARN("invalid parameter: status == NULL\n"); return DSERR_INVALIDPARAM; } *status = 0; if (!device->stopped) *status |= DSBSTATUS_PLAYING | DSBSTATUS_LOOPING; TRACE("status=%x\n", *status); return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_GetFormat(IDirectSoundBuffer8 *iface, WAVEFORMATEX *lpwf, DWORD wfsize, DWORD *wfwritten) { DWORD size; IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%p,%d,%p)\n", iface, lpwf, wfsize, wfwritten); size = sizeof(WAVEFORMATEX) + device->primary_pwfx->cbSize; if (lpwf) { /* NULL is valid */ if (wfsize >= size) { CopyMemory(lpwf,device->primary_pwfx,size); if (wfwritten) *wfwritten = size; } else { WARN("invalid parameter: wfsize too small\n"); if (wfwritten) *wfwritten = 0; return DSERR_INVALIDPARAM; } } else { if (wfwritten) *wfwritten = sizeof(WAVEFORMATEX) + device->primary_pwfx->cbSize; else { WARN("invalid parameter: wfwritten == NULL\n"); return DSERR_INVALIDPARAM; } } return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_Lock(IDirectSoundBuffer8 *iface, DWORD writecursor, DWORD writebytes, void **lplpaudioptr1, DWORD *audiobytes1, void **lplpaudioptr2, DWORD *audiobytes2, DWORD flags) { HRESULT hres; IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%d,%d,%p,%p,%p,%p,0x%08x) at %d\n", iface, writecursor, writebytes, lplpaudioptr1, audiobytes1, lplpaudioptr2, audiobytes2, flags, GetTickCount() ); if (!audiobytes1) return DSERR_INVALIDPARAM; if (device->priolevel != DSSCL_WRITEPRIMARY) { WARN("failed priority check!\n"); return DSERR_PRIOLEVELNEEDED; } /* when this flag is set, writecursor is meaningless and must be calculated */ if (flags & DSBLOCK_FROMWRITECURSOR) { /* GetCurrentPosition does too much magic to duplicate here */ hres = IDirectSoundBuffer_GetCurrentPosition(iface, NULL, &writecursor); if (hres != DS_OK) { WARN("IDirectSoundBuffer_GetCurrentPosition failed\n"); return hres; } } /* when this flag is set, writebytes is meaningless and must be set */ if (flags & DSBLOCK_ENTIREBUFFER) writebytes = device->buflen; if (writecursor >= device->buflen) { WARN("Invalid parameter, writecursor: %u >= buflen: %u\n", writecursor, device->buflen); return DSERR_INVALIDPARAM; } if (writebytes > device->buflen) { WARN("Invalid parameter, writebytes: %u > buflen: %u\n", writebytes, device->buflen); return DSERR_INVALIDPARAM; } if (writecursor+writebytes <= device->buflen) { *(LPBYTE*)lplpaudioptr1 = device->buffer+writecursor; *audiobytes1 = writebytes; if (lplpaudioptr2) *(LPBYTE*)lplpaudioptr2 = NULL; if (audiobytes2) *audiobytes2 = 0; TRACE("->%d.0\n",writebytes); } else { *(LPBYTE*)lplpaudioptr1 = device->buffer+writecursor; *audiobytes1 = device->buflen-writecursor; if (lplpaudioptr2) *(LPBYTE*)lplpaudioptr2 = device->buffer; if (audiobytes2) *audiobytes2 = writebytes-(device->buflen-writecursor); TRACE("->%d.%d\n",*audiobytes1,audiobytes2?*audiobytes2:0); } return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_SetCurrentPosition(IDirectSoundBuffer8 *iface, DWORD newpos) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); TRACE("(%p,%d)\n",This,newpos); /* You cannot set the position of the primary buffer */ WARN("invalid call\n"); return DSERR_INVALIDCALL; } static HRESULT WINAPI PrimaryBufferImpl_SetPan(IDirectSoundBuffer8 *iface, LONG pan) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; float fvol; HRESULT hr; int i; TRACE("(%p,%d)\n", iface, pan); if (!(This->dsbd.dwFlags & DSBCAPS_CTRLPAN)) { WARN("control unavailable\n"); return DSERR_CONTROLUNAVAIL; } if ((pan > DSBPAN_RIGHT) || (pan < DSBPAN_LEFT)) { WARN("invalid parameter: pan = %d\n", pan); return DSERR_INVALIDPARAM; } /* **** */ EnterCriticalSection(&device->mixlock); for (i = 0; i < DS_MAX_CHANNELS; i++) { if (device->pwfx->nChannels > i){ hr = IAudioStreamVolume_GetChannelVolume(device->volume, i, &fvol); if (FAILED(hr)){ LeaveCriticalSection(&device->mixlock); WARN("GetChannelVolume failed: %08x\n", hr); return hr; } } else fvol = 1; device->volpan.dwTotalAmpFactor[i] = ((UINT16)(fvol * (DWORD)0xFFFF)); } DSOUND_AmpFactorToVolPan(&device->volpan); if (pan != device->volpan.lPan) { device->volpan.lPan=pan; DSOUND_RecalcVolPan(&device->volpan); for (i = 0; i < DS_MAX_CHANNELS; i++) { if (device->pwfx->nChannels > i) { fvol = (float)((DWORD)(device->volpan.dwTotalAmpFactor[i] & 0xFFFF) / (float)0xFFFF); hr = IAudioStreamVolume_SetChannelVolume(device->volume, i, fvol); if (FAILED(hr)){ LeaveCriticalSection(&device->mixlock); WARN("SetChannelVolume failed: %08x\n", hr); return hr; } } } } LeaveCriticalSection(&device->mixlock); /* **** */ return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_GetPan(IDirectSoundBuffer8 *iface, LONG *pan) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; float fvol; HRESULT hr; int i; TRACE("(%p,%p)\n", iface, pan); if (!(This->dsbd.dwFlags & DSBCAPS_CTRLPAN)) { WARN("control unavailable\n"); return DSERR_CONTROLUNAVAIL; } if (pan == NULL) { WARN("invalid parameter: pan == NULL\n"); return DSERR_INVALIDPARAM; } EnterCriticalSection(&device->mixlock); for (i = 0; i < DS_MAX_CHANNELS; i++) { if (device->pwfx->nChannels > i) { hr = IAudioStreamVolume_GetChannelVolume(device->volume, i, &fvol); if (FAILED(hr)){ LeaveCriticalSection(&device->mixlock); WARN("GetChannelVolume failed: %08x\n", hr); return hr; } } else fvol = 1; device->volpan.dwTotalAmpFactor[i] = ((UINT16)(fvol * (DWORD)0xFFFF)); } DSOUND_AmpFactorToVolPan(&device->volpan); *pan = device->volpan.lPan; LeaveCriticalSection(&device->mixlock); return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_Unlock(IDirectSoundBuffer8 *iface, void *p1, DWORD x1, void *p2, DWORD x2) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%p,%d,%p,%d)\n", iface, p1, x1, p2, x2); if (device->priolevel != DSSCL_WRITEPRIMARY) { WARN("failed priority check!\n"); return DSERR_PRIOLEVELNEEDED; } if ((p1 && ((BYTE*)p1 < device->buffer || (BYTE*)p1 >= device->buffer + device->buflen)) || (p2 && ((BYTE*)p2 < device->buffer || (BYTE*)p2 >= device->buffer + device->buflen))) return DSERR_INVALIDPARAM; return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_Restore(IDirectSoundBuffer8 *iface) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); FIXME("(%p):stub\n",This); return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_GetFrequency(IDirectSoundBuffer8 *iface, DWORD *freq) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%p)\n", iface, freq); if (freq == NULL) { WARN("invalid parameter: freq == NULL\n"); return DSERR_INVALIDPARAM; } if (!(This->dsbd.dwFlags & DSBCAPS_CTRLFREQUENCY)) { WARN("control unavailable\n"); return DSERR_CONTROLUNAVAIL; } *freq = device->pwfx->nSamplesPerSec; TRACE("-> %d\n", *freq); return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_Initialize(IDirectSoundBuffer8 *iface, IDirectSound *dsound, const DSBUFFERDESC *dbsd) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); WARN("(%p) already initialized\n", This); return DSERR_ALREADYINITIALIZED; } static HRESULT WINAPI PrimaryBufferImpl_GetCaps(IDirectSoundBuffer8 *iface, DSBCAPS *caps) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); DirectSoundDevice *device = This->device; TRACE("(%p,%p)\n", iface, caps); if (caps == NULL) { WARN("invalid parameter: caps == NULL\n"); return DSERR_INVALIDPARAM; } if (caps->dwSize < sizeof(*caps)) { WARN("invalid parameter: caps->dwSize = %d\n", caps->dwSize); return DSERR_INVALIDPARAM; } caps->dwFlags = This->dsbd.dwFlags; caps->dwBufferBytes = device->buflen; /* Windows reports these as zero */ caps->dwUnlockTransferRate = 0; caps->dwPlayCpuOverhead = 0; return DS_OK; } static HRESULT WINAPI PrimaryBufferImpl_QueryInterface(IDirectSoundBuffer8 *iface, REFIID riid, void **ppobj) { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppobj); if (ppobj == NULL) { WARN("invalid parameter\n"); return E_INVALIDARG; } *ppobj = NULL; /* assume failure */ if ( IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDirectSoundBuffer) ) { IDirectSoundBuffer_AddRef(iface); *ppobj = iface; return S_OK; } /* DirectSoundBuffer and DirectSoundBuffer8 are different and */ /* a primary buffer can't have a DirectSoundBuffer8 interface */ if ( IsEqualGUID( &IID_IDirectSoundBuffer8, riid ) ) { WARN("app requested DirectSoundBuffer8 on primary buffer\n"); return E_NOINTERFACE; } if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) { ERR("app requested IDirectSoundNotify on primary buffer\n"); /* FIXME: should we support this? */ return E_NOINTERFACE; } if ( IsEqualGUID( &IID_IDirectSound3DBuffer, riid ) ) { ERR("app requested IDirectSound3DBuffer on primary buffer\n"); return E_NOINTERFACE; } if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) { *ppobj = &This->IDirectSound3DListener_iface; IDirectSound3DListener_AddRef(&This->IDirectSound3DListener_iface); return S_OK; } if ( IsEqualGUID( &IID_IKsPropertySet, riid ) ) { *ppobj = &This->IKsPropertySet_iface; IKsPropertySet_AddRef(&This->IKsPropertySet_iface); return S_OK; } FIXME( "Unknown IID %s\n", debugstr_guid( riid ) ); return E_NOINTERFACE; } static const IDirectSoundBuffer8Vtbl dspbvt = { PrimaryBufferImpl_QueryInterface, PrimaryBufferImpl_AddRef, PrimaryBufferImpl_Release, PrimaryBufferImpl_GetCaps, PrimaryBufferImpl_GetCurrentPosition, PrimaryBufferImpl_GetFormat, PrimaryBufferImpl_GetVolume, PrimaryBufferImpl_GetPan, PrimaryBufferImpl_GetFrequency, PrimaryBufferImpl_GetStatus, PrimaryBufferImpl_Initialize, PrimaryBufferImpl_Lock, PrimaryBufferImpl_Play, PrimaryBufferImpl_SetCurrentPosition, PrimaryBufferImpl_SetFormat, PrimaryBufferImpl_SetVolume, PrimaryBufferImpl_SetPan, PrimaryBufferImpl_SetFrequency, PrimaryBufferImpl_Stop, PrimaryBufferImpl_Unlock, PrimaryBufferImpl_Restore }; HRESULT primarybuffer_create(DirectSoundDevice *device, IDirectSoundBufferImpl **ppdsb, const DSBUFFERDESC *dsbd) { IDirectSoundBufferImpl *dsb; TRACE("%p,%p,%p)\n",device,ppdsb,dsbd); if (dsbd->lpwfxFormat) { WARN("invalid parameter: dsbd->lpwfxFormat != NULL\n"); *ppdsb = NULL; return DSERR_INVALIDPARAM; } dsb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsb)); if (dsb == NULL) { WARN("out of memory\n"); *ppdsb = NULL; return DSERR_OUTOFMEMORY; } dsb->ref = 0; dsb->ref3D = 0; dsb->refiks = 0; dsb->numIfaces = 0; dsb->device = device; dsb->IDirectSoundBuffer8_iface.lpVtbl = &dspbvt; dsb->IDirectSound3DListener_iface.lpVtbl = &ds3dlvt; dsb->IKsPropertySet_iface.lpVtbl = &iksbvt; dsb->dsbd = *dsbd; /* IDirectSound3DListener */ 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->ds3dl_need_recalc = TRUE; TRACE("Created primary buffer at %p\n", dsb); TRACE("(formattag=0x%04x,chans=%d,samplerate=%d," "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n", device->pwfx->wFormatTag, device->pwfx->nChannels, device->pwfx->nSamplesPerSec, device->pwfx->nAvgBytesPerSec, device->pwfx->nBlockAlign, device->pwfx->wBitsPerSample, device->pwfx->cbSize); IDirectSoundBuffer8_AddRef(&dsb->IDirectSoundBuffer8_iface); *ppdsb = dsb; return S_OK; }