| /* 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_IDirectSoundBuffer(IDirectSoundBuffer *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(IDirectSoundBuffer *iface, | |
| const WAVEFORMATEX *wfex) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface); | |
| TRACE("(%p,%p)\n", iface, wfex); | |
| return primarybuffer_SetFormat(This->device, wfex); | |
| } | |
| static HRESULT WINAPI PrimaryBufferImpl_SetVolume(IDirectSoundBuffer *iface, LONG vol) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, LONG *vol) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, DWORD freq) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, DWORD reserved1, | |
| DWORD reserved2, DWORD flags) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface); | |
| DirectSoundDevice *device = This->device; | |
| TRACE("(%p)\n", iface); | |
| device->stopped = 1; | |
| return DS_OK; | |
| } | |
| static ULONG WINAPI PrimaryBufferImpl_AddRef(IDirectSoundBuffer *iface) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, | |
| DWORD *playpos, DWORD *writepos) | |
| { | |
| HRESULT hres = DS_OK; | |
| UINT32 pad = 0; | |
| UINT32 mixpos; | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, DWORD *status) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, WAVEFORMATEX *lpwf, | |
| DWORD wfsize, DWORD *wfwritten) | |
| { | |
| DWORD size; | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, DWORD writecursor, | |
| DWORD writebytes, void **lplpaudioptr1, DWORD *audiobytes1, void **lplpaudioptr2, | |
| DWORD *audiobytes2, DWORD flags) | |
| { | |
| HRESULT hres; | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, DWORD newpos) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, LONG pan) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, LONG *pan) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, void *p1, DWORD x1, | |
| void *p2, DWORD x2) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface); | |
| FIXME("(%p):stub\n",This); | |
| return DS_OK; | |
| } | |
| static HRESULT WINAPI PrimaryBufferImpl_GetFrequency(IDirectSoundBuffer *iface, DWORD *freq) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, IDirectSound *dsound, | |
| const DSBUFFERDESC *dbsd) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface); | |
| WARN("(%p) already initialized\n", This); | |
| return DSERR_ALREADYINITIALIZED; | |
| } | |
| static HRESULT WINAPI PrimaryBufferImpl_GetCaps(IDirectSoundBuffer *iface, DSBCAPS *caps) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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(IDirectSoundBuffer *iface, REFIID riid, | |
| void **ppobj) | |
| { | |
| IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(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 IDirectSoundBufferVtbl 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 = (IDirectSoundBuffer8Vtbl *)&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); | |
| IDirectSoundBuffer_AddRef(&dsb->IDirectSoundBuffer8_iface); | |
| *ppdsb = dsb; | |
| return S_OK; | |
| } |