dsound_private.h File Reference

#include <wine/config.h>
#include <assert.h>
#include <math.h>
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winnls.h>
#include <wingdi.h>
#include <winternl.h>
#include <objbase.h>
#include <audioclient.h>
#include <mmddk.h>
#include <dsound.h>
#include <dsconf.h>
#include <dsdriver.h>
#include <vfwmsgs.h>
#include <wine/debug.h>
#include <wine/list.h>

Include dependency graph for dsound_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	DirectSoundDevice
struct	BufferMemory
struct	IDirectSoundBufferImpl
struct	DirectSoundCaptureDevice
struct	IDirectSoundCaptureBufferImpl
struct	IDirectSound3DListenerImpl
struct	IKsBufferPropertySetImpl
struct	IDirectSound3DBufferImpl

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	COBJMACROS
#define	NONAMELESSSTRUCT
#define	NONAMELESSUNION
#define	DS_TIME_RES   2 /* Resolution of multimedia timer */
#define	DS_TIME_DEL   10 /* Delay of multimedia timer callback, and duration of HEL fragment */
#define	DS_HW_ACCEL_FULL   0 /* default on Windows 98 */
#define	DS_HW_ACCEL_STANDARD   1 /* default on Windows 2000 */
#define	DS_HW_ACCEL_BASIC   2
#define	DS_HW_ACCEL_EMULATION   3
#define	STATE_STOPPED   0
#define	STATE_STARTING   1
#define	STATE_PLAYING   2
#define	STATE_CAPTURING   2
#define	STATE_STOPPING   3
#define	DSOUND_FREQSHIFT   (20)

Typedefs
typedef struct IDirectSoundImpl	IDirectSoundImpl
typedef struct IDirectSound_IUnknown	IDirectSound_IUnknown
typedef struct IDirectSound_IDirectSound	IDirectSound_IDirectSound
typedef struct IDirectSound8_IUnknown	IDirectSound8_IUnknown
typedef struct IDirectSound8_IDirectSound	IDirectSound8_IDirectSound
typedef struct IDirectSound8_IDirectSound8	IDirectSound8_IDirectSound8
typedef struct IDirectSoundBufferImpl	IDirectSoundBufferImpl
typedef struct IDirectSoundCaptureImpl	IDirectSoundCaptureImpl
typedef struct IDirectSoundCaptureBufferImpl	IDirectSoundCaptureBufferImpl
typedef struct IDirectSoundNotifyImpl	IDirectSoundNotifyImpl
typedef struct IDirectSoundCaptureNotifyImpl	IDirectSoundCaptureNotifyImpl
typedef struct IDirectSound3DListenerImpl	IDirectSound3DListenerImpl
typedef struct IDirectSound3DBufferImpl	IDirectSound3DBufferImpl
typedef struct IKsBufferPropertySetImpl	IKsBufferPropertySetImpl
typedef struct DirectSoundDevice	DirectSoundDevice
typedef struct DirectSoundCaptureDevice	DirectSoundCaptureDevice
typedef void(*	bitsconvertfunc) (const void *, void *, UINT, UINT, INT, UINT, UINT)
typedef void(*	mixfunc) (const void *, void *, unsigned)
typedef void(*	normfunc) (const void *, void *, unsigned)
typedef struct BufferMemory	BufferMemory

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dsound)
ULONG	DirectSoundDevice_Release (DirectSoundDevice *device) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_Initialize (DirectSoundDevice **ppDevice, LPCGUID lpcGUID) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_AddBuffer (DirectSoundDevice *device, IDirectSoundBufferImpl *pDSB) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_RemoveBuffer (DirectSoundDevice *device, IDirectSoundBufferImpl *pDSB) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_GetCaps (DirectSoundDevice *device, LPDSCAPS lpDSCaps) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_CreateSoundBuffer (DirectSoundDevice *device, LPCDSBUFFERDESC dsbd, LPLPDIRECTSOUNDBUFFER ppdsb, LPUNKNOWN lpunk, BOOL from8) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_DuplicateSoundBuffer (DirectSoundDevice *device, LPDIRECTSOUNDBUFFER psb, LPLPDIRECTSOUNDBUFFER ppdsb) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_SetCooperativeLevel (DirectSoundDevice *devcie, HWND hwnd, DWORD level) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_Compact (DirectSoundDevice *device) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_GetSpeakerConfig (DirectSoundDevice *device, LPDWORD lpdwSpeakerConfig) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_SetSpeakerConfig (DirectSoundDevice *device, DWORD config) DECLSPEC_HIDDEN
HRESULT	DirectSoundDevice_VerifyCertification (DirectSoundDevice *device, LPDWORD pdwCertified) DECLSPEC_HIDDEN
HRESULT	IDirectSoundBufferImpl_Create (DirectSoundDevice *device, IDirectSoundBufferImpl **ppdsb, LPCDSBUFFERDESC dsbd) DECLSPEC_HIDDEN
HRESULT	IDirectSoundBufferImpl_Destroy (IDirectSoundBufferImpl *pdsb) DECLSPEC_HIDDEN
HRESULT	IDirectSoundBufferImpl_Duplicate (DirectSoundDevice *device, IDirectSoundBufferImpl **ppdsb, IDirectSoundBufferImpl *pdsb) DECLSPEC_HIDDEN
void	secondarybuffer_destroy (IDirectSoundBufferImpl *This) DECLSPEC_HIDDEN
HRESULT	IDirectSound3DListenerImpl_Create (DirectSoundDevice *device, IDirectSound3DListenerImpl **pdsl) DECLSPEC_HIDDEN
HRESULT	IKsBufferPropertySetImpl_Create (IDirectSoundBufferImpl *dsb, IKsBufferPropertySetImpl **piks) DECLSPEC_HIDDEN
HRESULT	IKsBufferPropertySetImpl_Destroy (IKsBufferPropertySetImpl *piks) DECLSPEC_HIDDEN
HRESULT	IKsPrivatePropertySetImpl_Create (REFIID riid, IKsPropertySet **piks) DECLSPEC_HIDDEN
HRESULT	IDirectSound3DBufferImpl_Create (IDirectSoundBufferImpl *dsb, IDirectSound3DBufferImpl **pds3db) DECLSPEC_HIDDEN
HRESULT	IDirectSound3DBufferImpl_Destroy (IDirectSound3DBufferImpl *pds3db) DECLSPEC_HIDDEN
HRESULT	DSOUND_Create (REFIID riid, LPDIRECTSOUND *ppDS) DECLSPEC_HIDDEN
HRESULT	DSOUND_Create8 (REFIID riid, LPDIRECTSOUND8 *ppDS) DECLSPEC_HIDDEN
DWORD	DSOUND_fraglen (DWORD nSamplesPerSec, DWORD nBlockAlign) DECLSPEC_HIDDEN
HRESULT	DSOUND_PrimaryCreate (DirectSoundDevice *device) DECLSPEC_HIDDEN
HRESULT	DSOUND_PrimaryDestroy (DirectSoundDevice *device) DECLSPEC_HIDDEN
HRESULT	DSOUND_PrimaryPlay (DirectSoundDevice *device) DECLSPEC_HIDDEN
HRESULT	DSOUND_PrimaryStop (DirectSoundDevice *device) DECLSPEC_HIDDEN
HRESULT	DSOUND_PrimaryGetPosition (DirectSoundDevice *device, LPDWORD playpos, LPDWORD writepos) DECLSPEC_HIDDEN
LPWAVEFORMATEX	DSOUND_CopyFormat (LPCWAVEFORMATEX wfex) DECLSPEC_HIDDEN
HRESULT	DSOUND_ReopenDevice (DirectSoundDevice *device, BOOL forcewave) DECLSPEC_HIDDEN
HRESULT	primarybuffer_create (DirectSoundDevice *device, IDirectSoundBufferImpl **ppdsb, const DSBUFFERDESC *dsbd) DECLSPEC_HIDDEN
void	primarybuffer_destroy (IDirectSoundBufferImpl *This) DECLSPEC_HIDDEN
HRESULT	primarybuffer_SetFormat (DirectSoundDevice *device, LPCWAVEFORMATEX wfex) DECLSPEC_HIDDEN
HRESULT	DSOUND_FullDuplexCreate (REFIID riid, LPDIRECTSOUNDFULLDUPLEX *ppDSFD) DECLSPEC_HIDDEN
DWORD	DSOUND_bufpos_to_mixpos (const DirectSoundDevice *device, DWORD pos) DECLSPEC_HIDDEN
void	DSOUND_CheckEvent (const IDirectSoundBufferImpl *dsb, DWORD playpos, int len) DECLSPEC_HIDDEN
void	DSOUND_RecalcVolPan (PDSVOLUMEPAN volpan) DECLSPEC_HIDDEN
void	DSOUND_AmpFactorToVolPan (PDSVOLUMEPAN volpan) DECLSPEC_HIDDEN
void	DSOUND_RecalcFormat (IDirectSoundBufferImpl *dsb) DECLSPEC_HIDDEN
void	DSOUND_MixToTemporary (const IDirectSoundBufferImpl *dsb, DWORD writepos, DWORD mixlen, BOOL inmixer) DECLSPEC_HIDDEN
DWORD	DSOUND_secpos_to_bufpos (const IDirectSoundBufferImpl *dsb, DWORD secpos, DWORD secmixpos, DWORD *overshot) DECLSPEC_HIDDEN
void CALLBACK	DSOUND_timer (UINT timerID, UINT msg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) DECLSPEC_HIDDEN
void CALLBACK	DSOUND_callback (HWAVEOUT hwo, UINT msg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) DECLSPEC_HIDDEN
void	DSOUND_Calc3DBuffer (IDirectSoundBufferImpl *dsb) DECLSPEC_HIDDEN
HRESULT	DSOUND_CaptureCreate (REFIID riid, LPDIRECTSOUNDCAPTURE *ppDSC) DECLSPEC_HIDDEN
HRESULT	DSOUND_CaptureCreate8 (REFIID riid, LPDIRECTSOUNDCAPTURE8 *ppDSC8) DECLSPEC_HIDDEN
HRESULT	mmErr (UINT err) DECLSPEC_HIDDEN
void	setup_dsound_options (void) DECLSPEC_HIDDEN
const char *	dumpCooperativeLevel (DWORD level) DECLSPEC_HIDDEN

Variables
int ds_emuldriver	DECLSPEC_HIDDEN

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 32 of file dsound_private.h.

COBJMACROS

#define COBJMACROS

Definition at line 35 of file dsound_private.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 33 of file dsound_private.h.

DS_HW_ACCEL_BASIC

#define DS_HW_ACCEL_BASIC   2

Definition at line 64 of file dsound_private.h.

DS_HW_ACCEL_EMULATION

#define DS_HW_ACCEL_EMULATION   3

Definition at line 65 of file dsound_private.h.

DS_HW_ACCEL_FULL

#define DS_HW_ACCEL_FULL   0 /* default on Windows 98 */

Definition at line 62 of file dsound_private.h.

DS_HW_ACCEL_STANDARD

#define DS_HW_ACCEL_STANDARD   1 /* default on Windows 2000 */

Definition at line 63 of file dsound_private.h.

DS_TIME_DEL

#define DS_TIME_DEL   10 /* Delay of multimedia timer callback, and duration of HEL fragment */

Definition at line 59 of file dsound_private.h.

DS_TIME_RES

#define DS_TIME_RES   2 /* Resolution of multimedia timer */

Definition at line 58 of file dsound_private.h.

DSOUND_FREQSHIFT

#define DSOUND_FREQSHIFT   (20)

Definition at line 405 of file dsound_private.h.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 36 of file dsound_private.h.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 37 of file dsound_private.h.

STATE_CAPTURING

#define STATE_CAPTURING   2

Definition at line 402 of file dsound_private.h.

STATE_PLAYING

#define STATE_PLAYING   2

Definition at line 401 of file dsound_private.h.

STATE_STARTING

#define STATE_STARTING   1

Definition at line 400 of file dsound_private.h.

STATE_STOPPED

#define STATE_STOPPED   0

Definition at line 399 of file dsound_private.h.

STATE_STOPPING

#define STATE_STOPPING   3

Definition at line 403 of file dsound_private.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 31 of file dsound_private.h.

Typedef Documentation

bitsconvertfunc

typedef void(* bitsconvertfunc) (const void *, void *, UINT, UINT, INT, UINT, UINT)

Definition at line 97 of file dsound_private.h.

BufferMemory

typedef struct BufferMemory BufferMemory

DirectSoundCaptureDevice

typedef struct DirectSoundCaptureDevice DirectSoundCaptureDevice

Definition at line 94 of file dsound_private.h.

DirectSoundDevice

typedef struct DirectSoundDevice DirectSoundDevice

Definition at line 93 of file dsound_private.h.

IDirectSound3DBufferImpl

typedef struct IDirectSound3DBufferImpl IDirectSound3DBufferImpl

Definition at line 91 of file dsound_private.h.

IDirectSound3DListenerImpl

typedef struct IDirectSound3DListenerImpl IDirectSound3DListenerImpl

Definition at line 90 of file dsound_private.h.

IDirectSound8_IDirectSound

typedef struct IDirectSound8_IDirectSound IDirectSound8_IDirectSound

Definition at line 83 of file dsound_private.h.

IDirectSound8_IDirectSound8

typedef struct IDirectSound8_IDirectSound8 IDirectSound8_IDirectSound8

Definition at line 84 of file dsound_private.h.

IDirectSound8_IUnknown

typedef struct IDirectSound8_IUnknown IDirectSound8_IUnknown

Definition at line 82 of file dsound_private.h.

IDirectSound_IDirectSound

typedef struct IDirectSound_IDirectSound IDirectSound_IDirectSound

Definition at line 81 of file dsound_private.h.

IDirectSound_IUnknown

typedef struct IDirectSound_IUnknown IDirectSound_IUnknown

Definition at line 80 of file dsound_private.h.

IDirectSoundBufferImpl

typedef struct IDirectSoundBufferImpl IDirectSoundBufferImpl

Definition at line 85 of file dsound_private.h.

IDirectSoundCaptureBufferImpl

typedef struct IDirectSoundCaptureBufferImpl IDirectSoundCaptureBufferImpl

Definition at line 87 of file dsound_private.h.

IDirectSoundCaptureImpl

typedef struct IDirectSoundCaptureImpl IDirectSoundCaptureImpl

Definition at line 86 of file dsound_private.h.

IDirectSoundCaptureNotifyImpl

typedef struct IDirectSoundCaptureNotifyImpl IDirectSoundCaptureNotifyImpl

Definition at line 89 of file dsound_private.h.

IDirectSoundImpl

typedef struct IDirectSoundImpl IDirectSoundImpl

Definition at line 79 of file dsound_private.h.

IDirectSoundNotifyImpl

typedef struct IDirectSoundNotifyImpl IDirectSoundNotifyImpl

Definition at line 88 of file dsound_private.h.

IKsBufferPropertySetImpl

typedef struct IKsBufferPropertySetImpl IKsBufferPropertySetImpl

Definition at line 92 of file dsound_private.h.

mixfunc

typedef void(* mixfunc) (const void *, void *, unsigned)

Definition at line 99 of file dsound_private.h.

normfunc

typedef void(* normfunc) (const void *, void *, unsigned)

Definition at line 101 of file dsound_private.h.

Function Documentation

DirectSoundDevice_AddBuffer()

HRESULT DirectSoundDevice_AddBuffer	(	DirectSoundDevice *	device,
		IDirectSoundBufferImpl *	pDSB
	)

Definition at line 1761 of file dsound.c.

{
    IDirectSoundBufferImpl **newbuffers;
    HRESULT hr = DS_OK;
 
    TRACE("(%p, %p)\n", device, pDSB);
 
    RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
 
    if (device->buffers)
        newbuffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
    else
        newbuffers = HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
 
    if (newbuffers) {
        device->buffers = newbuffers;
        device->buffers[device->nrofbuffers] = pDSB;
        device->nrofbuffers++;
        TRACE("buffer count is now %d\n", device->nrofbuffers);
    } else {
        ERR("out of memory for buffer list! Current buffer count is %d\n", device->nrofbuffers);
        hr = DSERR_OUTOFMEMORY;
    }
 
    RtlReleaseResource(&(device->buffer_list_lock));
 
    return hr;
}

Referenced by IDirectSoundBufferImpl_Create(), and IDirectSoundBufferImpl_Duplicate().

DirectSoundDevice_Compact()

HRESULT DirectSoundDevice_Compact

(

DirectSoundDevice *

device

)

Definition at line 1683 of file dsound.c.

{
    TRACE("(%p)\n", device);
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    if (device->priolevel < DSSCL_PRIORITY) {
        WARN("incorrect priority level\n");
        return DSERR_PRIOLEVELNEEDED;
    }
 
    return DS_OK;
}

Referenced by IDirectSound8_IDirectSound8_Compact(), IDirectSound8_IDirectSound_Compact(), and IDirectSound_IDirectSound_Compact().

DirectSoundDevice_CreateSoundBuffer()

HRESULT DirectSoundDevice_CreateSoundBuffer	(	DirectSoundDevice *	device,
		LPCDSBUFFERDESC	dsbd,
		LPLPDIRECTSOUNDBUFFER	ppdsb,
		LPUNKNOWN	lpunk,
		BOOL	from8
	)

Definition at line 1482 of file dsound.c.

{
    HRESULT hres = DS_OK;
    TRACE("(%p,%p,%p,%p)\n",device,dsbd,ppdsb,lpunk);
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    if (dsbd == NULL) {
        WARN("invalid parameter: dsbd == NULL\n");
        return DSERR_INVALIDPARAM;
    }
 
    if (dsbd->dwSize != sizeof(DSBUFFERDESC) &&
        dsbd->dwSize != sizeof(DSBUFFERDESC1)) {
        WARN("invalid parameter: dsbd\n");
        return DSERR_INVALIDPARAM;
    }
 
    if (ppdsb == NULL) {
        WARN("invalid parameter: ppdsb == NULL\n");
        return DSERR_INVALIDPARAM;
    }
    *ppdsb = NULL;
 
    if (TRACE_ON(dsound)) {
        TRACE("(structsize=%d)\n",dsbd->dwSize);
        TRACE("(flags=0x%08x:\n",dsbd->dwFlags);
        _dump_DSBCAPS(dsbd->dwFlags);
        TRACE(")\n");
        TRACE("(bufferbytes=%d)\n",dsbd->dwBufferBytes);
        TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
    }
 
    if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
        if (dsbd->lpwfxFormat != NULL) {
            WARN("invalid parameter: dsbd->lpwfxFormat must be NULL for "
                 "primary buffer\n");
            return DSERR_INVALIDPARAM;
        }
 
        if (device->primary) {
            WARN("Primary Buffer already created\n");
            IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(device->primary));
            *ppdsb = (LPDIRECTSOUNDBUFFER)(device->primary);
        } else {
            hres = primarybuffer_create(device, &device->primary, dsbd);
            if (device->primary) {
                *ppdsb = (IDirectSoundBuffer*)&device->primary->IDirectSoundBuffer8_iface;
                device->primary->dsbd.dwFlags &= ~(DSBCAPS_LOCHARDWARE | DSBCAPS_LOCSOFTWARE);
                if (device->hwbuf)
                    device->primary->dsbd.dwFlags |= DSBCAPS_LOCHARDWARE;
                else
                    device->primary->dsbd.dwFlags |= DSBCAPS_LOCSOFTWARE;
            } else
                WARN("primarybuffer_create() failed\n");
        }
    } else {
        IDirectSoundBufferImpl * dsb;
        WAVEFORMATEXTENSIBLE *pwfxe;
 
        if (dsbd->lpwfxFormat == NULL) {
            WARN("invalid parameter: dsbd->lpwfxFormat can't be NULL for "
                 "secondary buffer\n");
            return DSERR_INVALIDPARAM;
        }
        pwfxe = (WAVEFORMATEXTENSIBLE*)dsbd->lpwfxFormat;
 
        if (pwfxe->Format.wBitsPerSample != 16 && pwfxe->Format.wBitsPerSample != 8 && pwfxe->Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE)
        {
            WARN("wBitsPerSample=%d needs a WAVEFORMATEXTENSIBLE\n", dsbd->lpwfxFormat->wBitsPerSample);
            return DSERR_CONTROLUNAVAIL;
        }
        if (pwfxe->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE)
        {
            /* check if cbSize is at least 22 bytes */
            if (pwfxe->Format.cbSize < (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)))
            {
                WARN("Too small a cbSize %u\n", pwfxe->Format.cbSize);
                return DSERR_INVALIDPARAM;
            }
 
            /* cbSize should be 22 bytes, with one possible exception */
            if (pwfxe->Format.cbSize > (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)) &&
                !((IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM) || IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) &&
                pwfxe->Format.cbSize == sizeof(WAVEFORMATEXTENSIBLE)))
            {
                WARN("Too big a cbSize %u\n", pwfxe->Format.cbSize);
                return DSERR_CONTROLUNAVAIL;
            }
 
            if ((!IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)) && (!IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)))
            {
                if (!IsEqualGUID(&pwfxe->SubFormat, &GUID_NULL))
                    FIXME("SubFormat %s not supported right now.\n", debugstr_guid(&pwfxe->SubFormat));
                return DSERR_INVALIDPARAM;
            }
            if (pwfxe->Samples.wValidBitsPerSample > dsbd->lpwfxFormat->wBitsPerSample)
            {
                WARN("Samples.wValidBitsPerSample(%d) > Format.wBitsPerSample (%d)\n", pwfxe->Samples.wValidBitsPerSample, pwfxe->Format.wBitsPerSample);
                return DSERR_INVALIDPARAM;
            }
            if (pwfxe->Samples.wValidBitsPerSample && pwfxe->Samples.wValidBitsPerSample < dsbd->lpwfxFormat->wBitsPerSample)
            {
                FIXME("Non-packed formats not supported right now: %d/%d\n", pwfxe->Samples.wValidBitsPerSample, dsbd->lpwfxFormat->wBitsPerSample);
                return DSERR_CONTROLUNAVAIL;
            }
        }
 
        TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
              "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
              dsbd->lpwfxFormat->wFormatTag, dsbd->lpwfxFormat->nChannels,
              dsbd->lpwfxFormat->nSamplesPerSec,
              dsbd->lpwfxFormat->nAvgBytesPerSec,
              dsbd->lpwfxFormat->nBlockAlign,
              dsbd->lpwfxFormat->wBitsPerSample, dsbd->lpwfxFormat->cbSize);
 
        if (from8 && (dsbd->dwFlags & DSBCAPS_CTRL3D) && (dsbd->lpwfxFormat->nChannels != 1)) {
            WARN("invalid parameter: 3D buffer format must be mono\n");
            return DSERR_INVALIDPARAM;
        }
 
        hres = IDirectSoundBufferImpl_Create(device, &dsb, dsbd);
        if (dsb)
            *ppdsb = (IDirectSoundBuffer*)&dsb->IDirectSoundBuffer8_iface;
        else
            WARN("IDirectSoundBufferImpl_Create failed\n");
   }
 
   return hres;
}

Referenced by IDirectSound8_IDirectSound8_CreateSoundBuffer(), IDirectSound8_IDirectSound_CreateSoundBuffer(), and IDirectSound_IDirectSound_CreateSoundBuffer().

DirectSoundDevice_DuplicateSoundBuffer()

HRESULT DirectSoundDevice_DuplicateSoundBuffer	(	DirectSoundDevice *	device,
		LPDIRECTSOUNDBUFFER	psb,
		LPLPDIRECTSOUNDBUFFER	ppdsb
	)

Definition at line 1621 of file dsound.c.

{
    HRESULT hres = DS_OK;
    IDirectSoundBufferImpl* dsb;
    TRACE("(%p,%p,%p)\n",device,psb,ppdsb);
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    if (psb == NULL) {
        WARN("invalid parameter: psb == NULL\n");
        return DSERR_INVALIDPARAM;
    }
 
    if (ppdsb == NULL) {
        WARN("invalid parameter: ppdsb == NULL\n");
        return DSERR_INVALIDPARAM;
    }
 
    /* make sure we have a secondary buffer */
    if (psb == (IDirectSoundBuffer *)&device->primary->IDirectSoundBuffer8_iface) {
        WARN("trying to duplicate primary buffer\n");
        *ppdsb = NULL;
        return DSERR_INVALIDCALL;
    }
 
    /* duplicate the actual buffer implementation */
    hres = IDirectSoundBufferImpl_Duplicate(device, &dsb, (IDirectSoundBufferImpl*)psb);
    if (hres == DS_OK)
        *ppdsb = (IDirectSoundBuffer*)&dsb->IDirectSoundBuffer8_iface;
    else
        WARN("IDirectSoundBufferImpl_Duplicate failed\n");
 
    return hres;
}

Referenced by IDirectSound8_IDirectSound8_DuplicateSoundBuffer(), IDirectSound8_IDirectSound_DuplicateSoundBuffer(), and IDirectSound_IDirectSound_DuplicateSoundBuffer().

DirectSoundDevice_GetCaps()

HRESULT DirectSoundDevice_GetCaps	(	DirectSoundDevice *	device,
		LPDSCAPS	lpDSCaps
	)

Definition at line 1272 of file dsound.c.

{
    TRACE("(%p,%p)\n",device,lpDSCaps);
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    if (lpDSCaps == NULL) {
        WARN("invalid parameter: lpDSCaps = NULL\n");
        return DSERR_INVALIDPARAM;
    }
 
    /* check if there is enough room */
    if (lpDSCaps->dwSize < sizeof(*lpDSCaps)) {
        WARN("invalid parameter: lpDSCaps->dwSize = %d\n", lpDSCaps->dwSize);
        return DSERR_INVALIDPARAM;
    }
 
    lpDSCaps->dwFlags                           = device->drvcaps.dwFlags;
    if (TRACE_ON(dsound)) {
        TRACE("(flags=0x%08x:\n",lpDSCaps->dwFlags);
        _dump_DSCAPS(lpDSCaps->dwFlags);
        TRACE(")\n");
    }
    lpDSCaps->dwMinSecondarySampleRate          = device->drvcaps.dwMinSecondarySampleRate;
    lpDSCaps->dwMaxSecondarySampleRate          = device->drvcaps.dwMaxSecondarySampleRate;
    lpDSCaps->dwPrimaryBuffers                  = device->drvcaps.dwPrimaryBuffers;
    lpDSCaps->dwMaxHwMixingAllBuffers           = device->drvcaps.dwMaxHwMixingAllBuffers;
    lpDSCaps->dwMaxHwMixingStaticBuffers        = device->drvcaps.dwMaxHwMixingStaticBuffers;
    lpDSCaps->dwMaxHwMixingStreamingBuffers     = device->drvcaps.dwMaxHwMixingStreamingBuffers;
    lpDSCaps->dwFreeHwMixingAllBuffers          = device->drvcaps.dwFreeHwMixingAllBuffers;
    lpDSCaps->dwFreeHwMixingStaticBuffers       = device->drvcaps.dwFreeHwMixingStaticBuffers;
    lpDSCaps->dwFreeHwMixingStreamingBuffers    = device->drvcaps.dwFreeHwMixingStreamingBuffers;
    lpDSCaps->dwMaxHw3DAllBuffers               = device->drvcaps.dwMaxHw3DAllBuffers;
    lpDSCaps->dwMaxHw3DStaticBuffers            = device->drvcaps.dwMaxHw3DStaticBuffers;
    lpDSCaps->dwMaxHw3DStreamingBuffers         = device->drvcaps.dwMaxHw3DStreamingBuffers;
    lpDSCaps->dwFreeHw3DAllBuffers              = device->drvcaps.dwFreeHw3DAllBuffers;
    lpDSCaps->dwFreeHw3DStaticBuffers           = device->drvcaps.dwFreeHw3DStaticBuffers;
    lpDSCaps->dwFreeHw3DStreamingBuffers        = device->drvcaps.dwFreeHw3DStreamingBuffers;
    lpDSCaps->dwTotalHwMemBytes                 = device->drvcaps.dwTotalHwMemBytes;
    lpDSCaps->dwFreeHwMemBytes                  = device->drvcaps.dwFreeHwMemBytes;
    lpDSCaps->dwMaxContigFreeHwMemBytes         = device->drvcaps.dwMaxContigFreeHwMemBytes;
 
    /* driver doesn't have these */
    lpDSCaps->dwUnlockTransferRateHwBuffers     = 4096; /* But we have none... */
    lpDSCaps->dwPlayCpuOverheadSwBuffers        = 1;    /* 1% */
 
    return DS_OK;
}

Referenced by IDirectSound8_IDirectSound8_GetCaps(), IDirectSound8_IDirectSound_GetCaps(), and IDirectSound_IDirectSound_GetCaps().

DirectSoundDevice_GetSpeakerConfig()

HRESULT DirectSoundDevice_GetSpeakerConfig	(	DirectSoundDevice *	device,
		LPDWORD	lpdwSpeakerConfig
	)

Definition at line 1701 of file dsound.c.

{
    TRACE("(%p, %p)\n", device, lpdwSpeakerConfig);
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    if (lpdwSpeakerConfig == NULL) {
        WARN("invalid parameter: lpdwSpeakerConfig == NULL\n");
        return DSERR_INVALIDPARAM;
    }
 
    WARN("not fully functional\n");
    *lpdwSpeakerConfig = device->speaker_config;
    return DS_OK;
}

Referenced by IDirectSound8_IDirectSound8_GetSpeakerConfig(), IDirectSound8_IDirectSound_GetSpeakerConfig(), and IDirectSound_IDirectSound_GetSpeakerConfig().

DirectSoundDevice_Initialize()

HRESULT DirectSoundDevice_Initialize	(	DirectSoundDevice **	ppDevice,
		LPCGUID	lpcGUID
	)

Definition at line 1326 of file dsound.c.

{
    HRESULT hr = DS_OK;
    unsigned wod, wodn;
    BOOLEAN found = FALSE;
    GUID devGUID;
    DirectSoundDevice * device = *ppDevice;
    TRACE("(%p,%s)\n",ppDevice,debugstr_guid(lpcGUID));
 
    if (*ppDevice != NULL) {
        WARN("already initialized\n");
        return DSERR_ALREADYINITIALIZED;
    }
 
    /* Default device? */
    if (!lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL))
        lpcGUID = &DSDEVID_DefaultPlayback;
 
    if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) {
        WARN("invalid parameter: lpcGUID\n");
        return DSERR_INVALIDPARAM;
    }
 
    /* Enumerate WINMM audio devices and find the one we want */
    wodn = waveOutGetNumDevs();
    if (!wodn) {
        WARN("no driver\n");
        return DSERR_NODRIVER;
    }
 
    for (wod=0; wod<wodn; wod++) {
        if (IsEqualGUID( &devGUID, &DSOUND_renderer_guids[wod])) {
            found = TRUE;
            break;
        }
    }
 
    if (found == FALSE) {
        WARN("No device found matching given ID!\n");
        return DSERR_NODRIVER;
    }
 
    if (DSOUND_renderer[wod]) {
        if (IsEqualGUID(&devGUID, &DSOUND_renderer[wod]->guid)) {
            device = DSOUND_renderer[wod];
            DirectSoundDevice_AddRef(device);
            *ppDevice = device;
            return DS_OK;
        } else {
            ERR("device GUID doesn't match\n");
            hr = DSERR_GENERIC;
            return hr;
        }
    } else {
        hr = DirectSoundDevice_Create(&device);
        if (hr != DS_OK) {
            WARN("DirectSoundDevice_Create failed\n");
            return hr;
        }
    }
 
    *ppDevice = device;
    device->guid = devGUID;
    device->driver = NULL;
 
    device->drvdesc.dnDevNode = wod;
    hr = DSOUND_ReopenDevice(device, FALSE);
    if (FAILED(hr))
    {
        WARN("DSOUND_ReopenDevice failed: %08x\n", hr);
        return hr;
    }
 
    if (device->driver) {
        /* the driver is now open, so it's now allowed to call GetCaps */
        hr = IDsDriver_GetCaps(device->driver,&(device->drvcaps));
        if (hr != DS_OK) {
            WARN("IDsDriver_GetCaps failed\n");
            return hr;
        }
    } else {
        WAVEOUTCAPSA woc;
        hr = mmErr(waveOutGetDevCapsA(device->drvdesc.dnDevNode, &woc, sizeof(woc)));
        if (hr != DS_OK) {
            WARN("waveOutGetDevCaps failed\n");
            return hr;
        }
        ZeroMemory(&device->drvcaps, sizeof(device->drvcaps));
        if ((woc.dwFormats & WAVE_FORMAT_1M08) ||
            (woc.dwFormats & WAVE_FORMAT_2M08) ||
            (woc.dwFormats & WAVE_FORMAT_4M08) ||
            (woc.dwFormats & WAVE_FORMAT_48M08) ||
            (woc.dwFormats & WAVE_FORMAT_96M08)) {
            device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
            device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
        }
        if ((woc.dwFormats & WAVE_FORMAT_1M16) ||
            (woc.dwFormats & WAVE_FORMAT_2M16) ||
            (woc.dwFormats & WAVE_FORMAT_4M16) ||
            (woc.dwFormats & WAVE_FORMAT_48M16) ||
            (woc.dwFormats & WAVE_FORMAT_96M16)) {
            device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
            device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
        }
        if ((woc.dwFormats & WAVE_FORMAT_1S08) ||
            (woc.dwFormats & WAVE_FORMAT_2S08) ||
            (woc.dwFormats & WAVE_FORMAT_4S08) ||
            (woc.dwFormats & WAVE_FORMAT_48S08) ||
            (woc.dwFormats & WAVE_FORMAT_96S08)) {
            device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
            device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
        }
        if ((woc.dwFormats & WAVE_FORMAT_1S16) ||
            (woc.dwFormats & WAVE_FORMAT_2S16) ||
            (woc.dwFormats & WAVE_FORMAT_4S16) ||
            (woc.dwFormats & WAVE_FORMAT_48S16) ||
            (woc.dwFormats & WAVE_FORMAT_96S16)) {
            device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
            device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
        }
        if (ds_emuldriver)
            device->drvcaps.dwFlags |= DSCAPS_EMULDRIVER;
        device->drvcaps.dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
        device->drvcaps.dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
        ZeroMemory(&device->volpan, sizeof(device->volpan));
    }
 
    hr = DSOUND_PrimaryCreate(device);
    if (hr == DS_OK) {
        UINT triggertime = DS_TIME_DEL, res = DS_TIME_RES, id;
        TIMECAPS time;
 
        DSOUND_renderer[device->drvdesc.dnDevNode] = device;
        timeGetDevCaps(&time, sizeof(TIMECAPS));
        TRACE("Minimum timer resolution: %u, max timer: %u\n", time.wPeriodMin, time.wPeriodMax);
        if (triggertime < time.wPeriodMin)
            triggertime = time.wPeriodMin;
        if (res < time.wPeriodMin)
            res = time.wPeriodMin;
        if (timeBeginPeriod(res) == TIMERR_NOCANDO)
            WARN("Could not set minimum resolution, don't expect sound\n");
        id = timeSetEvent(triggertime, res, DSOUND_timer, (DWORD_PTR)device, TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
        if (!id)
        {
            WARN("Timer not created! Retrying without TIME_KILL_SYNCHRONOUS\n");
            id = timeSetEvent(triggertime, res, DSOUND_timer, (DWORD_PTR)device, TIME_PERIODIC);
            if (!id) ERR("Could not create timer, sound playback will not occur\n");
        }
        DSOUND_renderer[device->drvdesc.dnDevNode]->timerID = id;
    } else {
        WARN("DSOUND_PrimaryCreate failed\n");
    }
 
    return hr;
}

Referenced by IDirectSound8_IDirectSound8_Initialize(), IDirectSound8_IDirectSound_Initialize(), and IDirectSound_IDirectSound_Initialize().

DirectSoundDevice_Release()

ULONG DirectSoundDevice_Release

(

DirectSoundDevice *

device

)

Definition at line 1216 of file dsound.c.

{
    HRESULT hr;
    ULONG ref = InterlockedDecrement(&(device->ref));
    TRACE("(%p) ref was %u\n", device, ref + 1);
    if (!ref) {
        int i;
        timeKillEvent(device->timerID);
        timeEndPeriod(DS_TIME_RES);
 
        /* The kill event should have allowed the timer process to expire
         * but try to grab the lock just in case. Can't hold lock because
         * IDirectSoundBufferImpl_Destroy also grabs the lock */
        RtlAcquireResourceShared(&(device->buffer_list_lock), TRUE);
        RtlReleaseResource(&(device->buffer_list_lock));
 
        /* It is allowed to release this object even when buffers are playing */
        if (device->buffers) {
            WARN("%d secondary buffers not released\n", device->nrofbuffers);
            for( i=0;i<device->nrofbuffers;i++)
                IDirectSoundBufferImpl_Destroy(device->buffers[i]);
        }
 
        if (device->primary) {
            WARN("primary buffer not released\n");
            IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)device->primary);
        }
 
        hr = DSOUND_PrimaryDestroy(device);
        if (hr != DS_OK)
            WARN("DSOUND_PrimaryDestroy failed\n");
 
        if (device->driver)
            IDsDriver_Close(device->driver);
 
        if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
            waveOutClose(device->hwo);
 
        if (device->driver)
            IDsDriver_Release(device->driver);
 
        DSOUND_renderer[device->drvdesc.dnDevNode] = NULL;
 
        HeapFree(GetProcessHeap(), 0, device->tmp_buffer);
        HeapFree(GetProcessHeap(), 0, device->mix_buffer);
        if (device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY)
            HeapFree(GetProcessHeap(), 0, device->buffer);
        RtlDeleteResource(&device->buffer_list_lock);
        device->mixlock.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&device->mixlock);
        HeapFree(GetProcessHeap(),0,device);
        TRACE("(%p) released\n", device);
    }
    return ref;
}

Referenced by IDirectSoundImpl_Release().

DirectSoundDevice_RemoveBuffer()

HRESULT DirectSoundDevice_RemoveBuffer	(	DirectSoundDevice *	device,
		IDirectSoundBufferImpl *	pDSB
	)

Definition at line 1796 of file dsound.c.

{
    int i;
    HRESULT hr = DS_OK;
 
    TRACE("(%p, %p)\n", device, pDSB);
 
    RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
 
    for (i = 0; i < device->nrofbuffers; i++)
        if (device->buffers[i] == pDSB)
            break;
 
    if (i < device->nrofbuffers) {
        /* Put the last buffer of the list in the (now empty) position */
        device->buffers[i] = device->buffers[device->nrofbuffers - 1];
        device->nrofbuffers--;
        device->buffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(LPDIRECTSOUNDBUFFER8)*device->nrofbuffers);
        TRACE("buffer count is now %d\n", device->nrofbuffers);
    }
 
    if (device->nrofbuffers == 0) {
        HeapFree(GetProcessHeap(),0,device->buffers);
        device->buffers = NULL;
    }
 
    RtlReleaseResource(&(device->buffer_list_lock));
 
    return hr;
}

Referenced by secondarybuffer_destroy().

DirectSoundDevice_SetCooperativeLevel()

HRESULT DirectSoundDevice_SetCooperativeLevel	(	DirectSoundDevice *	devcie,
		HWND	hwnd,
		DWORD	level
	)

Definition at line 1662 of file dsound.c.

{
    TRACE("(%p,%p,%s)\n",device,hwnd,dumpCooperativeLevel(level));
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    if (level==DSSCL_PRIORITY || level==DSSCL_EXCLUSIVE) {
        WARN("level=%s not fully supported\n",
             level==DSSCL_PRIORITY ? "DSSCL_PRIORITY" : "DSSCL_EXCLUSIVE");
    }
 
    device->priolevel = level;
    return DS_OK;
}

Referenced by IDirectSound8_IDirectSound8_SetCooperativeLevel(), IDirectSound8_IDirectSound_SetCooperativeLevel(), and IDirectSound_IDirectSound_SetCooperativeLevel().

DirectSoundDevice_SetSpeakerConfig()

HRESULT DirectSoundDevice_SetSpeakerConfig	(	DirectSoundDevice *	device,
		DWORD	config
	)

Definition at line 1722 of file dsound.c.

{
    TRACE("(%p,0x%08x)\n",device,config);
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    device->speaker_config = config;
    WARN("not fully functional\n");
    return DS_OK;
}

Referenced by IDirectSound8_IDirectSound8_SetSpeakerConfig(), IDirectSound8_IDirectSound_SetSpeakerConfig(), and IDirectSound_IDirectSound_SetSpeakerConfig().

DirectSoundDevice_VerifyCertification()

HRESULT DirectSoundDevice_VerifyCertification	(	DirectSoundDevice *	device,
		LPDWORD	pdwCertified
	)

Definition at line 1738 of file dsound.c.

{
    TRACE("(%p, %p)\n",device,pdwCertified);
 
    if (device == NULL) {
        WARN("not initialized\n");
        return DSERR_UNINITIALIZED;
    }
 
    if (device->drvcaps.dwFlags & DSCAPS_CERTIFIED)
        *pdwCertified = DS_CERTIFIED;
    else
        *pdwCertified = DS_UNCERTIFIED;
 
    return DS_OK;
}

Referenced by IDirectSound8_IDirectSound8_VerifyCertification().

DSOUND_AmpFactorToVolPan()

void DSOUND_AmpFactorToVolPan

(

PDSVOLUMEPAN

volpan

)

Definition at line 46 of file mixer.c.

{
    double left,right;
    TRACE("(%p)\n",volpan);
 
    TRACE("left=%x, right=%x\n",volpan->dwTotalLeftAmpFactor,volpan->dwTotalRightAmpFactor);
    if (volpan->dwTotalLeftAmpFactor==0)
        left=-10000;
    else
        left=600 * log(((double)volpan->dwTotalLeftAmpFactor) / 0xffff) / log(2);
    if (volpan->dwTotalRightAmpFactor==0)
        right=-10000;
    else
        right=600 * log(((double)volpan->dwTotalRightAmpFactor) / 0xffff) / log(2);
    if (left<right)
    {
        volpan->lVolume=right;
        volpan->dwVolAmpFactor=volpan->dwTotalRightAmpFactor;
    }
    else
    {
        volpan->lVolume=left;
        volpan->dwVolAmpFactor=volpan->dwTotalLeftAmpFactor;
    }
    if (volpan->lVolume < -10000)
        volpan->lVolume=-10000;
    volpan->lPan=right-left;
    if (volpan->lPan < -10000)
        volpan->lPan=-10000;
 
    TRACE("Vol=%d Pan=%d\n", volpan->lVolume, volpan->lPan);
}

Referenced by PrimaryBufferImpl_GetPan(), PrimaryBufferImpl_GetVolume(), PrimaryBufferImpl_SetPan(), and PrimaryBufferImpl_SetVolume().

DSOUND_bufpos_to_mixpos()

DWORD DSOUND_bufpos_to_mixpos	(	const DirectSoundDevice *	device,
		DWORD	pos
	)

Convert a primary buffer position to a pointer position for device->mix_buffer device: DirectSoundDevice for which to calculate pos: Primary buffer position to converts Returns: Offset for mix_buffer

Definition at line 84 of file mixer.c.

{
    DWORD ret = pos * 32 / device->pwfx->wBitsPerSample;
    if (device->pwfx->wBitsPerSample == 32)
        ret *= 2;
    return ret;
}

Referenced by DSOUND_MixInBuffer(), DSOUND_PerformMix(), DSOUND_PrimaryOpen(), and primarybuffer_SetFormat().

DSOUND_Calc3DBuffer()

void DSOUND_Calc3DBuffer

(

IDirectSoundBufferImpl *

dsb

)

Definition at line 141 of file sound3d.c.

{
    /* volume, at which the sound will be played after all calcs. */
    D3DVALUE lVolume = 0;
    /* stuff for distance related stuff calc. */
    D3DVECTOR vDistance;
    D3DVALUE flDistance = 0;
    /* panning related stuff */
    D3DVALUE flAngle;
    D3DVECTOR vLeft;
    /* doppler shift related stuff */
#if 0
    D3DVALUE flFreq, flBufferVel, flListenerVel;
#endif
 
    TRACE("(%p)\n",dsb);
 
    /* initial buffer volume */
    lVolume = dsb->ds3db_lVolume;
    
    switch (dsb->ds3db_ds3db.dwMode)
    {
        case DS3DMODE_DISABLE:
            TRACE("3D processing disabled\n");
            /* this one is here only to eliminate annoying warning message */
            DSOUND_RecalcVolPan (&dsb->volpan);
            break;
        case DS3DMODE_NORMAL:
            TRACE("Normal 3D processing mode\n");
            /* we need to calculate distance between buffer and listener*/
            vDistance = VectorBetweenTwoPoints(&dsb->ds3db_ds3db.vPosition, &dsb->device->ds3dl.vPosition);
            flDistance = VectorMagnitude (&vDistance);
            break;
        case DS3DMODE_HEADRELATIVE:
            TRACE("Head-relative 3D processing mode\n");
            /* distance between buffer and listener is same as buffer's position */
            flDistance = VectorMagnitude (&dsb->ds3db_ds3db.vPosition);
            break;
    }
    
    if (flDistance > dsb->ds3db_ds3db.flMaxDistance)
    {
        /* some apps don't want you to hear too distant sounds... */
        if (dsb->dsbd.dwFlags & DSBCAPS_MUTE3DATMAXDISTANCE)
        {
            dsb->volpan.lVolume = DSBVOLUME_MIN;
            DSOUND_RecalcVolPan (&dsb->volpan);     
            /* i guess mixing here would be a waste of power */
            return;
        }
        else
            flDistance = dsb->ds3db_ds3db.flMaxDistance;
    }       
 
    if (flDistance < dsb->ds3db_ds3db.flMinDistance)
        flDistance = dsb->ds3db_ds3db.flMinDistance;
    
    /* attenuation proportional to the distance squared, converted to millibels as in lVolume*/
    lVolume -= log10(flDistance/dsb->ds3db_ds3db.flMinDistance * flDistance/dsb->ds3db_ds3db.flMinDistance)*1000;
    TRACE("dist. att: Distance = %f, MinDistance = %f => adjusting volume %d to %f\n", flDistance, dsb->ds3db_ds3db.flMinDistance, dsb->ds3db_lVolume, lVolume);
 
    /* conning */
    /* sometimes it happens that vConeOrientation vector = (0,0,0); in this case angle is "nan" and it's useless*/
    if (dsb->ds3db_ds3db.vConeOrientation.x == 0 && dsb->ds3db_ds3db.vConeOrientation.y == 0 && dsb->ds3db_ds3db.vConeOrientation.z == 0)
    {
        TRACE("conning: cones not set\n");
    }
    else
    {
        /* calculate angle */
        flAngle = AngleBetweenVectorsDeg(&dsb->ds3db_ds3db.vConeOrientation, &vDistance);
        /* if by any chance it happens that OutsideConeAngle = InsideConeAngle (that means that conning has no effect) */
        if (dsb->ds3db_ds3db.dwInsideConeAngle != dsb->ds3db_ds3db.dwOutsideConeAngle)
        {
            /* my test show that for my way of calc., we need only half of angles */
            DWORD dwInsideConeAngle = dsb->ds3db_ds3db.dwInsideConeAngle/2;
            DWORD dwOutsideConeAngle = dsb->ds3db_ds3db.dwOutsideConeAngle/2;
            if (dwOutsideConeAngle == dwInsideConeAngle)
                ++dwOutsideConeAngle;
 
            /* full volume */
            if (flAngle < dwInsideConeAngle)
                flAngle = dwInsideConeAngle;
            /* min (app defined) volume */
            if (flAngle > dwOutsideConeAngle)
                flAngle = dwOutsideConeAngle;
            /* this probably isn't the right thing, but it's ok for the time being */
            lVolume += ((dsb->ds3db_ds3db.lConeOutsideVolume)/((dwOutsideConeAngle) - (dwInsideConeAngle))) * flAngle;
        }
        TRACE("conning: Angle = %f deg; InsideConeAngle(/2) = %d deg; OutsideConeAngle(/2) = %d deg; ConeOutsideVolume = %d => adjusting volume to %f\n",
               flAngle, dsb->ds3db_ds3db.dwInsideConeAngle/2, dsb->ds3db_ds3db.dwOutsideConeAngle/2, dsb->ds3db_ds3db.lConeOutsideVolume, lVolume);
    }
    dsb->volpan.lVolume = lVolume;
    
    /* panning */
    if (dsb->device->ds3dl.vPosition.x == dsb->ds3db_ds3db.vPosition.x &&
        dsb->device->ds3dl.vPosition.y == dsb->ds3db_ds3db.vPosition.y &&
        dsb->device->ds3dl.vPosition.z == dsb->ds3db_ds3db.vPosition.z) {
        dsb->volpan.lPan = 0;
        flAngle = 0.0;
    }
    else
    {
        vDistance = VectorBetweenTwoPoints(&dsb->device->ds3dl.vPosition, &dsb->ds3db_ds3db.vPosition);
        vLeft = VectorProduct(&dsb->device->ds3dl.vOrientFront, &dsb->device->ds3dl.vOrientTop);
        flAngle = AngleBetweenVectorsRad(&vLeft, &vDistance);
        /* 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;
    }
    TRACE("panning: Angle = %f rad, lPan = %d\n", flAngle, dsb->volpan.lPan);
 
    /* FIXME: Doppler Effect disabled since i have no idea which frequency to change and how to do it */
#if 0   
    /* doppler shift*/
    if ((VectorMagnitude(&ds3db_ds3db.vVelocity) == 0) && (VectorMagnitude(&dsb->device->ds3dl.vVelocity) == 0))
    {
        TRACE("doppler: Buffer and Listener don't have velocities\n");
    }
    else if (ds3db_ds3db.vVelocity != dsb->device->ds3dl.vVelocity)
    {
        /* calculate length of ds3db_ds3db.vVelocity component which causes Doppler Effect
           NOTE: if buffer moves TOWARDS the listener, it's velocity component is NEGATIVE
                 if buffer moves AWAY from listener, it's velocity component is POSITIVE */
        flBufferVel = ProjectVector(&dsb->ds3db_ds3db.vVelocity, &vDistance);
        /* calculate length of ds3dl.vVelocity component which causes Doppler Effect
           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 */
        flListenerVel = ProjectVector(&dsb->device->ds3dl.vVelocity, &vDistance);
        /* formula taken from Gianicoli D.: Physics, 4th edition: */
        /* FIXME: replace dsb->freq with appropriate frequency ! */
        flFreq = dsb->freq * ((DEFAULT_VELOCITY + flListenerVel)/(DEFAULT_VELOCITY + flBufferVel));
        TRACE("doppler: Buffer velocity (component) = %lf, Listener velocity (component) = %lf => Doppler shift: %ld Hz -> %lf Hz\n", flBufferVel, flListenerVel,
              dsb->freq, flFreq);
        /* FIXME: replace following line with correct frequency setting ! */
        dsb->freq = flFreq;
        DSOUND_RecalcFormat(dsb);
        DSOUND_MixToTemporary(dsb, 0, dsb->buflen);
    }
#endif  
    
    /* time for remix */
    DSOUND_RecalcVolPan(&dsb->volpan);
}

Referenced by DSOUND_Mix3DBuffer(), IDirectSoundBufferImpl_Create(), and IDirectSoundBufferImpl_SetVolume().

DSOUND_callback()

void CALLBACK DSOUND_callback	(	HWAVEOUT	hwo,
		UINT	msg,
		DWORD_PTR	dwUser,
		DWORD_PTR	dw1,
		DWORD_PTR	dw2
	)

Definition at line 1011 of file mixer.c.

{
    DirectSoundDevice * device = (DirectSoundDevice*)dwUser;
    TRACE("(%p,%x,%lx,%lx,%lx)\n",hwo,msg,dwUser,dw1,dw2);
    TRACE("entering at %d, msg=%08x(%s)\n", GetTickCount(), msg,
        msg==MM_WOM_DONE ? "MM_WOM_DONE" : msg==MM_WOM_CLOSE ? "MM_WOM_CLOSE" : 
        msg==MM_WOM_OPEN ? "MM_WOM_OPEN" : "UNKNOWN");
 
    /* check if packet completed from wave driver */
    if (msg == MM_WOM_DONE) {
 
        /* **** */
        EnterCriticalSection(&(device->mixlock));
 
        TRACE("done playing primary pos=%d\n", device->pwplay * device->fraglen);
 
        /* update playpos */
        device->pwplay++;
        device->pwplay %= device->helfrags;
 
        /* sanity */
        if(device->pwqueue == 0){
            ERR("Wave queue corrupted!\n");
        }
 
        /* update queue */
        device->pwqueue--;
 
        LeaveCriticalSection(&(device->mixlock));
        /* **** */
    }
    TRACE("completed\n");
}

Referenced by DSOUND_ReopenDevice().

DSOUND_CaptureCreate()

HRESULT DSOUND_CaptureCreate	(	REFIID	riid,
		LPDIRECTSOUNDCAPTURE *	ppDSC
	)

Definition at line 1336 of file capture.c.

{
    LPDIRECTSOUNDCAPTURE pDSC;
    HRESULT hr;
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSC);
 
    if (!IsEqualIID(riid, &IID_IUnknown) &&
        !IsEqualIID(riid, &IID_IDirectSoundCapture)) {
        *ppDSC = 0;
        return E_NOINTERFACE;
    }
 
    /* Get dsound configuration */
    setup_dsound_options();
 
    hr = IDirectSoundCaptureImpl_Create(&pDSC);
    if (hr == DS_OK) {
        IDirectSoundCapture_AddRef(pDSC);
        *ppDSC = pDSC;
    } else {
        WARN("IDirectSoundCaptureImpl_Create failed\n");
        *ppDSC = 0;
    }
 
    return hr;
}

Referenced by DirectSoundCaptureCreate().

DSOUND_CaptureCreate8()

HRESULT DSOUND_CaptureCreate8	(	REFIID	riid,
		LPDIRECTSOUNDCAPTURE8 *	ppDSC8
	)

Definition at line 1365 of file capture.c.

{
    LPDIRECTSOUNDCAPTURE8 pDSC8;
    HRESULT hr;
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSC8);
 
    if (!IsEqualIID(riid, &IID_IUnknown) &&
        !IsEqualIID(riid, &IID_IDirectSoundCapture8)) {
        *ppDSC8 = 0;
        return E_NOINTERFACE;
    }
 
    /* Get dsound configuration */
    setup_dsound_options();
 
    hr = IDirectSoundCaptureImpl_Create(&pDSC8);
    if (hr == DS_OK) {
        IDirectSoundCapture_AddRef(pDSC8);
        *ppDSC8 = pDSC8;
    } else {
        WARN("IDirectSoundCaptureImpl_Create failed\n");
        *ppDSC8 = 0;
    }
 
    return hr;
}

Referenced by DirectSoundCaptureCreate8(), and IDirectSoundFullDuplexImpl_Initialize().

DSOUND_CheckEvent()

void DSOUND_CheckEvent	(	const IDirectSoundBufferImpl *	dsb,
		DWORD	playpos,
		int	len
	)

Check for application callback requests for when the play position reaches certain points.

The offsets that will be triggered will be those between the recorded "last played" position for the buffer (i.e. dsb->playpos) and "len" bytes beyond that position.

Definition at line 221 of file mixer.c.

{
    int         i;
    DWORD           offset;
    LPDSBPOSITIONNOTIFY event;
    TRACE("(%p,%d)\n",dsb,len);
 
    if (dsb->nrofnotifies == 0)
        return;
 
    TRACE("(%p) buflen = %d, playpos = %d, len = %d\n",
        dsb, dsb->buflen, playpos, len);
    for (i = 0; i < dsb->nrofnotifies ; i++) {
        event = dsb->notifies + i;
        offset = event->dwOffset;
        TRACE("checking %d, position %d, event = %p\n",
            i, offset, event->hEventNotify);
        /* DSBPN_OFFSETSTOP has to be the last element. So this is */
        /* OK. [Inside DirectX, p274] */
        /* Windows does not seem to enforce this, and some apps rely */
        /* on that, so we can't stop there. */
        /*  */
        /* This also means we can't sort the entries by offset, */
        /* because DSBPN_OFFSETSTOP == -1 */
        if (offset == DSBPN_OFFSETSTOP) {
            if (dsb->state == STATE_STOPPED) {
                SetEvent(event->hEventNotify);
                TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
            }
                        continue;
        }
        if ((playpos + len) >= dsb->buflen) {
            if ((offset < ((playpos + len) % dsb->buflen)) ||
                (offset >= playpos)) {
                TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
                SetEvent(event->hEventNotify);
            }
        } else {
            if ((offset >= playpos) && (offset < (playpos + len))) {
                TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
                SetEvent(event->hEventNotify);
            }
        }
    }
}

Referenced by DSOUND_MixInBuffer(), DSOUND_MixToPrimary(), and IDirectSoundBufferImpl_Stop().

DSOUND_CopyFormat()

LPWAVEFORMATEX DSOUND_CopyFormat

(

LPCWAVEFORMATEX

wfex

)

Definition at line 437 of file primary.c.

{
    DWORD size = DSOUND_GetFormatSize(wfex);
    LPWAVEFORMATEX pwfx = HeapAlloc(GetProcessHeap(),0,size);
    if (pwfx == NULL) {
        WARN("out of memory\n");
    } else if (wfex->wFormatTag != WAVE_FORMAT_PCM) {
        CopyMemory(pwfx, wfex, size);
    } else {
        CopyMemory(pwfx, wfex, sizeof(PCMWAVEFORMAT));
        pwfx->cbSize=0;
        if (pwfx->nBlockAlign != pwfx->nChannels * pwfx->wBitsPerSample/8) {
            WARN("Fixing bad nBlockAlign (%u)\n", pwfx->nBlockAlign);
            pwfx->nBlockAlign  = pwfx->nChannels * pwfx->wBitsPerSample/8;
        }
        if (pwfx->nAvgBytesPerSec != pwfx->nSamplesPerSec * pwfx->nBlockAlign) {
            WARN("Fixing bad nAvgBytesPerSec (%u)\n", pwfx->nAvgBytesPerSec);
            pwfx->nAvgBytesPerSec  = pwfx->nSamplesPerSec * pwfx->nBlockAlign;
        }
    }
    return pwfx;
}

Referenced by IDirectSoundBufferImpl_Create(), IDirectSoundBufferImpl_Duplicate(), IDirectSoundCaptureBufferImpl_Create(), and primarybuffer_SetFormat().

DSOUND_Create()

HRESULT DSOUND_Create	(	REFIID	riid,
		LPDIRECTSOUND *	ppDS
	)

Definition at line 963 of file dsound.c.

{
    LPDIRECTSOUND8 pDS;
    HRESULT hr;
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppDS);
 
    if (!IsEqualIID(riid, &IID_IUnknown) &&
        !IsEqualIID(riid, &IID_IDirectSound)) {
        *ppDS = 0;
        return E_NOINTERFACE;
    }
 
    /* Get dsound configuration */
    setup_dsound_options();
 
    hr = IDirectSoundImpl_Create(&pDS);
    if (hr == DS_OK) {
        hr = IDirectSound_IDirectSound_Create(pDS, ppDS);
        if (*ppDS)
            IDirectSound_IDirectSound_AddRef(*ppDS);
        else {
            WARN("IDirectSound_IDirectSound_Create failed\n");
            IDirectSound8_Release(pDS);
        }
    } else {
        WARN("IDirectSoundImpl_Create failed\n");
        *ppDS = 0;
    }
 
    return hr;
}

Referenced by DirectSoundCreate().

DSOUND_Create8()

HRESULT DSOUND_Create8	(	REFIID	riid,
		LPDIRECTSOUND8 *	ppDS
	)

Definition at line 1050 of file dsound.c.

{
    LPDIRECTSOUND8 pDS;
    HRESULT hr;
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppDS);
 
    if (!IsEqualIID(riid, &IID_IUnknown) &&
        !IsEqualIID(riid, &IID_IDirectSound) &&
        !IsEqualIID(riid, &IID_IDirectSound8)) {
        *ppDS = 0;
        return E_NOINTERFACE;
    }
 
    /* Get dsound configuration */
    setup_dsound_options();
 
    hr = IDirectSoundImpl_Create(&pDS);
    if (hr == DS_OK) {
        hr = IDirectSound8_IDirectSound8_Create(pDS, ppDS);
        if (*ppDS)
            IDirectSound8_IDirectSound8_AddRef(*ppDS);
        else {
            WARN("IDirectSound8_IDirectSound8_Create failed\n");
            IDirectSound8_Release(pDS);
        }
    } else {
        WARN("IDirectSoundImpl_Create failed\n");
        *ppDS = 0;
    }
 
    return hr;
}

Referenced by DirectSoundCreate8(), and IDirectSoundFullDuplexImpl_Initialize().

DSOUND_fraglen()

DWORD DSOUND_fraglen	(	DWORD	nSamplesPerSec,
		DWORD	nBlockAlign
	)

Calculate how long a fragment length of about 10 ms should be in frames

nSamplesPerSec: Frequency rate in samples per second nBlockAlign: Size of a single blockalign

Returns: Size in bytes of a single fragment

Definition at line 36 of file primary.c.

{
    /* Given a timer delay of 10ms, the fragment size is approximately:
     *     fraglen = (nSamplesPerSec * 10 / 1000) * nBlockAlign
     * ==> fraglen = (nSamplesPerSec / 100) * nBlockSize
     *
     * ALSA uses buffers that are powers of 2. Because of this, fraglen
     * is rounded up to the nearest power of 2:
     */
 
    if (nSamplesPerSec <= 12800)
        return 128 * nBlockAlign;
 
    if (nSamplesPerSec <= 25600)
        return 256 * nBlockAlign;
 
    if (nSamplesPerSec <= 51200)
        return 512 * nBlockAlign;
 
    return 1024 * nBlockAlign;
}

Referenced by DSOUND_RecalcPrimary(), and IDirectSoundCaptureBufferImpl_Start().

DSOUND_FullDuplexCreate()

HRESULT DSOUND_FullDuplexCreate	(	REFIID	riid,
		LPDIRECTSOUNDFULLDUPLEX *	ppDSFD
	)

Definition at line 604 of file duplex.c.

{
    IDirectSoundFullDuplexImpl *This = NULL;
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSFD);
 
    if (ppDSFD == NULL) {
        WARN("invalid parameter: ppDSFD == NULL\n");
        return DSERR_INVALIDPARAM;
    }
 
    if (!IsEqualIID(riid, &IID_IUnknown) &&
        !IsEqualIID(riid, &IID_IDirectSoundFullDuplex)) {
        *ppDSFD = 0;
        return E_NOINTERFACE;
    }
 
    /* Get dsound configuration */
    setup_dsound_options();
 
    This = HeapAlloc(GetProcessHeap(),
        HEAP_ZERO_MEMORY, sizeof(IDirectSoundFullDuplexImpl));
 
    if (This == NULL) {
        WARN("out of memory\n");
        *ppDSFD = NULL;
        return DSERR_OUTOFMEMORY;
    }
 
    This->lpVtbl = &dsfdvt;
    This->ref = 1;
    This->capture_device = NULL;
    This->renderer_device = NULL;
 
    *ppDSFD = (LPDIRECTSOUNDFULLDUPLEX)This;
 
    return DS_OK;
}

Referenced by DirectSoundFullDuplexCreate().

DSOUND_MixToTemporary()

void DSOUND_MixToTemporary	(	const IDirectSoundBufferImpl *	dsb,
		DWORD	writepos,
		DWORD	len,
		BOOL	inmixer
	)

Mix at most the given amount of data into the allocated temporary buffer of the given secondary buffer, starting from the dsb's first currently unsampled frame (writepos), translating frequency (pitch), stereo/mono and bits-per-sample so that it is ideal for the primary buffer. Doesn't perform any mixing - this is a straight copy/convert operation.

dsb = the secondary buffer writepos = Starting position of changed buffer len = number of bytes to resample from writepos

NOTE: writepos + len <= buflen. When called by mixer, MixOne makes sure of this.

Definition at line 332 of file mixer.c.

{
    INT size;
    BYTE    *ibp, *obp, *obp_begin;
    INT iAdvance = dsb->pwfx->nBlockAlign;
    INT oAdvance = dsb->device->pwfx->nBlockAlign;
    DWORD freqAcc, target_writepos = 0, overshot, maxlen;
 
    /* We resample only when needed */
    if ((dsb->tmp_buffer && inmixer) || (!dsb->tmp_buffer && !inmixer) || dsb->resampleinmixer != inmixer)
        return;
 
    assert(writepos + len <= dsb->buflen);
    if (inmixer && writepos + len < dsb->buflen)
        len += dsb->pwfx->nBlockAlign;
 
    maxlen = DSOUND_secpos_to_bufpos(dsb, len, 0, NULL);
 
    ibp = dsb->buffer->memory + writepos;
    if (!inmixer)
        obp_begin = dsb->tmp_buffer;
    else if (dsb->device->tmp_buffer_len < maxlen || !dsb->device->tmp_buffer)
    {
        dsb->device->tmp_buffer_len = maxlen;
        if (dsb->device->tmp_buffer)
            dsb->device->tmp_buffer = HeapReAlloc(GetProcessHeap(), 0, dsb->device->tmp_buffer, maxlen);
        else
            dsb->device->tmp_buffer = HeapAlloc(GetProcessHeap(), 0, maxlen);
        obp_begin = dsb->device->tmp_buffer;
    }
    else
        obp_begin = dsb->device->tmp_buffer;
 
    TRACE("(%p, %p)\n", dsb, ibp);
    size = len / iAdvance;
 
    /* Check for same sample rate */
    if (dsb->freq == dsb->device->pwfx->nSamplesPerSec) {
        TRACE("(%p) Same sample rate %d = primary %d\n", dsb,
            dsb->freq, dsb->device->pwfx->nSamplesPerSec);
        obp = obp_begin;
        if (!inmixer)
             obp += writepos/iAdvance*oAdvance;
 
        cp_fields(dsb, ibp, obp, iAdvance, oAdvance, size, 0, 1 << DSOUND_FREQSHIFT);
        return;
    }
 
    /* Mix in different sample rates */
    TRACE("(%p) Adjusting frequency: %d -> %d\n", dsb, dsb->freq, dsb->device->pwfx->nSamplesPerSec);
 
    target_writepos = DSOUND_secpos_to_bufpos(dsb, writepos, dsb->sec_mixpos, &freqAcc);
    overshot = freqAcc >> DSOUND_FREQSHIFT;
    if (overshot)
    {
        if (overshot >= size)
            return;
        size -= overshot;
        writepos += overshot * iAdvance;
        if (writepos >= dsb->buflen)
            return;
        ibp = dsb->buffer->memory + writepos;
        freqAcc &= (1 << DSOUND_FREQSHIFT) - 1;
        TRACE("Overshot: %d, freqAcc: %04x\n", overshot, freqAcc);
    }
 
    if (!inmixer)
        obp = obp_begin + target_writepos;
    else obp = obp_begin;
 
    /* FIXME: Small problem here when we're overwriting buf_mixpos, it then STILL uses old freqAcc, not sure if it matters or not */
    cp_fields(dsb, ibp, obp, iAdvance, oAdvance, size, freqAcc, dsb->freqAdjust);
}

Referenced by DSOUND_Calc3DBuffer(), DSOUND_MixInBuffer(), IDirectSoundBufferImpl_Duplicate(), IDirectSoundBufferImpl_SetFrequency(), IDirectSoundBufferImpl_Unlock(), and primarybuffer_SetFormat().

DSOUND_PrimaryCreate()

HRESULT DSOUND_PrimaryCreate

(

DirectSoundDevice *

device

)

Definition at line 304 of file primary.c.

{
    HRESULT err = DS_OK;
    TRACE("(%p)\n", device);
 
    device->buflen = ds_hel_buflen;
    err = DSOUND_PrimaryOpen(device);
 
    if (err != DS_OK) {
        WARN("DSOUND_PrimaryOpen failed\n");
        return err;
    }
 
    device->state = STATE_STOPPED;
    return DS_OK;
}

Referenced by DirectSoundDevice_Initialize().

DSOUND_PrimaryDestroy()

HRESULT DSOUND_PrimaryDestroy

(

DirectSoundDevice *

device

)

Definition at line 321 of file primary.c.

{
    TRACE("(%p)\n", device);
 
    /* **** */
    EnterCriticalSection(&(device->mixlock));
 
    DSOUND_PrimaryClose(device);
    if (device->driver) {
        if (device->hwbuf) {
            if (IDsDriverBuffer_Release(device->hwbuf) == 0)
                device->hwbuf = 0;
        }
    } else
                HeapFree(GetProcessHeap(),0,device->pwave);
        HeapFree(GetProcessHeap(),0,device->pwfx);
        device->pwfx=NULL;
 
    LeaveCriticalSection(&(device->mixlock));
    /* **** */
 
    return DS_OK;
}

Referenced by DirectSoundDevice_Release().

DSOUND_PrimaryGetPosition()

HRESULT DSOUND_PrimaryGetPosition	(	DirectSoundDevice *	device,
		LPDWORD	playpos,
		LPDWORD	writepos
	)

Definition at line 402 of file primary.c.

{
    TRACE("(%p,%p,%p)\n", device, playpos, writepos);
 
    if (device->hwbuf) {
        HRESULT err=IDsDriverBuffer_GetPosition(device->hwbuf,playpos,writepos);
        if (err != S_OK) {
            WARN("IDsDriverBuffer_GetPosition failed\n");
            return err;
        }
    } else {
        TRACE("pwplay=%i, pwqueue=%i\n", device->pwplay, device->pwqueue);
 
        /* check if playpos was requested */
        if (playpos)
            /* use the cached play position */
            *playpos = device->pwplay * device->fraglen;
 
        /* check if writepos was requested */
        if (writepos)
            /* the writepos is the first non-queued position */
            *writepos = ((device->pwplay + device->pwqueue) % device->helfrags) * device->fraglen;
    }
    TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:-1, writepos?*writepos:-1, device, GetTickCount());
    return DS_OK;
}

Referenced by DSOUND_PerformMix(), and PrimaryBufferImpl_GetCurrentPosition().

DSOUND_PrimaryPlay()

HRESULT DSOUND_PrimaryPlay

(

DirectSoundDevice *

device

)

Definition at line 345 of file primary.c.

{
    HRESULT err = DS_OK;
    TRACE("(%p)\n", device);
 
    if (device->hwbuf) {
        err = IDsDriverBuffer_Play(device->hwbuf, 0, 0, DSBPLAY_LOOPING);
        if (err != DS_OK)
            WARN("IDsDriverBuffer_Play failed\n");
    } else {
        err = mmErr(waveOutRestart(device->hwo));
        if (err != DS_OK)
            WARN("waveOutRestart failed\n");
    }
 
    return err;
}

Referenced by DSOUND_PerformMix().

DSOUND_PrimaryStop()

HRESULT DSOUND_PrimaryStop

(

DirectSoundDevice *

device

)

Definition at line 363 of file primary.c.

{
    HRESULT err = DS_OK;
    TRACE("(%p)\n", device);
 
    if (device->hwbuf) {
        err = IDsDriverBuffer_Stop(device->hwbuf);
        if (err == DSERR_BUFFERLOST) {
            DSOUND_PrimaryClose(device);
            err = DSOUND_ReopenDevice(device, FALSE);
            if (FAILED(err))
                ERR("DSOUND_ReopenDevice failed\n");
            else
            {
                err = DSOUND_PrimaryOpen(device);
                if (FAILED(err))
                    WARN("DSOUND_PrimaryOpen failed\n");
            }
        } else if (err != DS_OK) {
            WARN("IDsDriverBuffer_Stop failed\n");
        }
    } else {
 
        /* don't call the wave system with the lock set */
        LeaveCriticalSection(&(device->mixlock));
        /* **** */
 
        err = mmErr(waveOutPause(device->hwo));
 
        /* **** */
        EnterCriticalSection(&(device->mixlock));
 
        if (err != DS_OK)
            WARN("waveOutPause failed\n");
    }
 
    return err;
}

Referenced by DSOUND_PerformMix().

DSOUND_RecalcFormat()

void DSOUND_RecalcFormat

(

IDirectSoundBufferImpl *

dsb

)

Recalculate the size for temporary buffer, and new writelead Should be called when one of the following things occur:

• Primary buffer format is changed
• This buffer format (frequency) is changed

After this, DSOUND_MixToTemporary(dsb, 0, dsb->buflen) should be called to refill the temporary buffer with data.

Definition at line 162 of file mixer.c.

{
    BOOL needremix = TRUE, needresample = (dsb->freq != dsb->device->pwfx->nSamplesPerSec);
    DWORD bAlign = dsb->pwfx->nBlockAlign, pAlign = dsb->device->pwfx->nBlockAlign;
    WAVEFORMATEXTENSIBLE *pwfxe;
    BOOL ieee = FALSE;
 
    TRACE("(%p)\n",dsb);
 
    pwfxe = (WAVEFORMATEXTENSIBLE *) dsb->pwfx;
 
    if ((pwfxe->Format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT) || ((pwfxe->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE)
        && (IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))))
        ieee = TRUE;
 
    /* calculate the 10ms write lead */
    dsb->writelead = (dsb->freq / 100) * dsb->pwfx->nBlockAlign;
 
    if ((dsb->pwfx->wBitsPerSample == dsb->device->pwfx->wBitsPerSample) &&
        (dsb->pwfx->nChannels == dsb->device->pwfx->nChannels) && !needresample && !ieee)
        needremix = FALSE;
    HeapFree(GetProcessHeap(), 0, dsb->tmp_buffer);
    dsb->tmp_buffer = NULL;
    dsb->max_buffer_len = dsb->freqAcc = dsb->freqAccNext = 0;
    dsb->freqneeded = needresample;
 
    if (ieee)
        dsb->convert = convertbpp[4][dsb->device->pwfx->wBitsPerSample/8 - 1];
    else
        dsb->convert = convertbpp[dsb->pwfx->wBitsPerSample/8 - 1][dsb->device->pwfx->wBitsPerSample/8 - 1];
 
    dsb->resampleinmixer = FALSE;
 
    if (needremix)
    {
        if (needresample)
            DSOUND_RecalcFreqAcc(dsb);
        else
            dsb->tmp_buffer_len = dsb->buflen / bAlign * pAlign;
        dsb->max_buffer_len = dsb->tmp_buffer_len;
        if ((dsb->max_buffer_len <= dsb->device->buflen || dsb->max_buffer_len < ds_snd_shadow_maxsize * 1024 * 1024) && ds_snd_shadow_maxsize >= 0)
            dsb->tmp_buffer = HeapAlloc(GetProcessHeap(), 0, dsb->max_buffer_len);
        if (dsb->tmp_buffer)
            FillMemory(dsb->tmp_buffer, dsb->tmp_buffer_len, dsb->device->pwfx->wBitsPerSample == 8 ? 128 : 0);
        else
            dsb->resampleinmixer = TRUE;
    }
    else dsb->max_buffer_len = dsb->tmp_buffer_len = dsb->buflen;
    dsb->buf_mixpos = DSOUND_secpos_to_bufpos(dsb, dsb->sec_mixpos, 0, NULL);
}

Referenced by DSOUND_Calc3DBuffer(), IDirectSoundBufferImpl_Create(), IDirectSoundBufferImpl_Duplicate(), IDirectSoundBufferImpl_SetFrequency(), and primarybuffer_SetFormat().

DSOUND_RecalcVolPan()

void DSOUND_RecalcVolPan

(

PDSVOLUMEPAN

volpan

)

Definition at line 27 of file mixer.c.

{
    double temp;
    TRACE("(%p)\n",volpan);
 
    TRACE("Vol=%d Pan=%d\n", volpan->lVolume, volpan->lPan);
    /* the AmpFactors are expressed in 16.16 fixed point */
    volpan->dwVolAmpFactor = (ULONG) (pow(2.0, volpan->lVolume / 600.0) * 0xffff);
    /* FIXME: dwPan{Left|Right}AmpFactor */
 
    /* FIXME: use calculated vol and pan ampfactors */
    temp = (double) (volpan->lVolume - (volpan->lPan > 0 ? volpan->lPan : 0));
    volpan->dwTotalLeftAmpFactor = (ULONG) (pow(2.0, temp / 600.0) * 0xffff);
    temp = (double) (volpan->lVolume + (volpan->lPan < 0 ? volpan->lPan : 0));
    volpan->dwTotalRightAmpFactor = (ULONG) (pow(2.0, temp / 600.0) * 0xffff);
 
    TRACE("left = %x, right = %x\n", volpan->dwTotalLeftAmpFactor, volpan->dwTotalRightAmpFactor);
}

Referenced by DSOUND_Calc3DBuffer(), IDirectSoundBufferImpl_Create(), IDirectSoundBufferImpl_SetPan(), IDirectSoundBufferImpl_SetVolume(), PrimaryBufferImpl_SetPan(), and PrimaryBufferImpl_SetVolume().

DSOUND_ReopenDevice()

HRESULT DSOUND_ReopenDevice	(	DirectSoundDevice *	device,
		BOOL	forcewave
	)

Definition at line 73 of file primary.c.

{
    HRESULT hres = DS_OK;
    TRACE("(%p, %d)\n", device, forcewave);
 
    if (device->driver)
    {
        IDsDriver_Close(device->driver);
        if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
            waveOutClose(device->hwo);
        IDsDriver_Release(device->driver);
        device->driver = NULL;
        device->buffer = NULL;
        device->hwo = 0;
    }
    else if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
        waveOutClose(device->hwo);
 
    /* DRV_QUERYDSOUNDIFACE is a "Wine extension" to get the DSound interface */
    if (ds_hw_accel != DS_HW_ACCEL_EMULATION && !forcewave)
        waveOutMessage((HWAVEOUT)(DWORD_PTR)device->drvdesc.dnDevNode, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&device->driver, 0);
 
    /* Get driver description */
    if (device->driver) {
        DWORD wod = device->drvdesc.dnDevNode;
        hres = IDsDriver_GetDriverDesc(device->driver,&(device->drvdesc));
        device->drvdesc.dnDevNode = wod;
        if (FAILED(hres)) {
            WARN("IDsDriver_GetDriverDesc failed: %08x\n", hres);
            IDsDriver_Release(device->driver);
            device->driver = NULL;
        }
        }
 
        /* if no DirectSound interface available, use WINMM API instead */
    if (!device->driver)
        device->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT;
 
    if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
    {
        DWORD flags = CALLBACK_FUNCTION | WAVE_MAPPED;
 
        if (device->driver)
            flags |= WAVE_DIRECTSOUND;
 
        hres = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode, device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD_PTR)device, flags));
        if (FAILED(hres)) {
            WARN("waveOutOpen failed\n");
            if (device->driver)
            {
                IDsDriver_Release(device->driver);
                device->driver = NULL;
            }
            return hres;
        }
    }
 
    if (device->driver)
        hres = IDsDriver_Open(device->driver);
 
    return hres;
}

Referenced by DirectSoundDevice_Initialize(), DSOUND_PrimaryOpen(), DSOUND_PrimaryStop(), and primarybuffer_SetFormat().

DSOUND_secpos_to_bufpos()

DWORD DSOUND_secpos_to_bufpos	(	const IDirectSoundBufferImpl *	dsb,
		DWORD	secpos,
		DWORD	secmixpos,
		DWORD *	overshot
	)

This function converts a 'native' sample pointer to a resampled pointer that fits for primary secmixpos is used to decide which freqAcc is needed overshot tells what the 'actual' secpos is now (optional)

Definition at line 99 of file mixer.c.

{
    DWORD64 framelen = secpos / dsb->pwfx->nBlockAlign;
    DWORD64 freqAdjust = dsb->freqAdjust;
    DWORD64 acc, freqAcc;
 
    if (secpos < secmixpos)
        freqAcc = dsb->freqAccNext;
    else freqAcc = dsb->freqAcc;
    acc = (framelen << DSOUND_FREQSHIFT) + (freqAdjust - 1 - freqAcc);
    acc /= freqAdjust;
    if (overshot)
    {
        DWORD64 oshot = acc * freqAdjust + freqAcc;
        assert(oshot >= framelen << DSOUND_FREQSHIFT);
        oshot -= framelen << DSOUND_FREQSHIFT;
        *overshot = (DWORD)oshot;
        assert(*overshot < dsb->freqAdjust);
    }
    return (DWORD)acc * dsb->device->pwfx->nBlockAlign;
}

Referenced by DSOUND_MixToTemporary(), DSOUND_RecalcFormat(), DSOUND_RecalcFreqAcc(), and IDirectSoundBufferImpl_SetCurrentPosition().

DSOUND_timer()

void CALLBACK DSOUND_timer	(	UINT	timerID,
		UINT	msg,
		DWORD_PTR	dwUser,
		DWORD_PTR	dw1,
		DWORD_PTR	dw2
	)

Definition at line 984 of file mixer.c.

{
    DirectSoundDevice * device = (DirectSoundDevice*)dwUser;
    DWORD start_time =  GetTickCount();
    DWORD end_time;
    TRACE("(%d,%d,0x%lx,0x%lx,0x%lx)\n",timerID,msg,dwUser,dw1,dw2);
    TRACE("entering at %d\n", start_time);
 
    if (DSOUND_renderer[device->drvdesc.dnDevNode] != device) {
        ERR("dsound died without killing us?\n");
        timeKillEvent(timerID);
        timeEndPeriod(DS_TIME_RES);
        return;
    }
 
    RtlAcquireResourceShared(&(device->buffer_list_lock), TRUE);
 
    if (device->ref)
        DSOUND_PerformMix(device);
 
    RtlReleaseResource(&(device->buffer_list_lock));
 
    end_time = GetTickCount();
    TRACE("completed processing at %d, duration = %d\n", end_time, end_time - start_time);
}

Referenced by DirectSoundDevice_Initialize().

dumpCooperativeLevel()

const char * dumpCooperativeLevel

(

DWORD

level

)

Definition at line 92 of file dsound.c.

{
#define LE(x) case x: return #x
    switch (level) {
        LE(DSSCL_NORMAL);
        LE(DSSCL_PRIORITY);
        LE(DSSCL_EXCLUSIVE);
        LE(DSSCL_WRITEPRIMARY);
    }
#undef LE
    return wine_dbg_sprintf("Unknown(%08x)", level);
}

Referenced by DirectSoundDevice_SetCooperativeLevel(), IDirectSound8_IDirectSound8_SetCooperativeLevel(), IDirectSound8_IDirectSound_SetCooperativeLevel(), IDirectSound_IDirectSound_SetCooperativeLevel(), and IDirectSoundFullDuplex_IDirectSound8_SetCooperativeLevel().

IDirectSound3DBufferImpl_Create()

HRESULT IDirectSound3DBufferImpl_Create	(	IDirectSoundBufferImpl *	dsb,
		IDirectSound3DBufferImpl **	pds3db
	)

Definition at line 667 of file sound3d.c.

{
    IDirectSound3DBufferImpl *ds3db;
    TRACE("(%p,%p)\n",dsb,pds3db);
 
    ds3db = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*ds3db));
 
    if (ds3db == NULL) {
        WARN("out of memory\n");
        *pds3db = 0;
        return DSERR_OUTOFMEMORY;
    }
 
    ds3db->ref = 0;
    ds3db->dsb = dsb;
    ds3db->lpVtbl = &ds3dbvt;
 
    ds3db->dsb->ds3db_ds3db.dwSize = sizeof(DS3DBUFFER);
    ds3db->dsb->ds3db_ds3db.vPosition.x = 0.0;
    ds3db->dsb->ds3db_ds3db.vPosition.y = 0.0;
    ds3db->dsb->ds3db_ds3db.vPosition.z = 0.0;
    ds3db->dsb->ds3db_ds3db.vVelocity.x = 0.0;
    ds3db->dsb->ds3db_ds3db.vVelocity.y = 0.0;
    ds3db->dsb->ds3db_ds3db.vVelocity.z = 0.0;
    ds3db->dsb->ds3db_ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
    ds3db->dsb->ds3db_ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
    ds3db->dsb->ds3db_ds3db.vConeOrientation.x = 0.0;
    ds3db->dsb->ds3db_ds3db.vConeOrientation.y = 0.0;
    ds3db->dsb->ds3db_ds3db.vConeOrientation.z = 0.0;
    ds3db->dsb->ds3db_ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
    ds3db->dsb->ds3db_ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
    ds3db->dsb->ds3db_ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
    ds3db->dsb->ds3db_ds3db.dwMode = DS3DMODE_NORMAL;
 
    ds3db->dsb->ds3db_need_recalc = TRUE;
 
    *pds3db = ds3db;
    return S_OK;
}

Referenced by IDirectSoundBufferImpl_QueryInterface().

IDirectSound3DBufferImpl_Destroy()

HRESULT IDirectSound3DBufferImpl_Destroy

(

IDirectSound3DBufferImpl *

pds3db

)

Definition at line 709 of file sound3d.c.

{
    TRACE("(%p)\n",pds3db);
 
    while (IDirectSound3DBufferImpl_Release((LPDIRECTSOUND3DBUFFER)pds3db) > 0);
 
    return S_OK;
}

Referenced by IDirectSoundBufferImpl_Destroy().

IDirectSound3DListenerImpl_Create()

HRESULT IDirectSound3DListenerImpl_Create	(	DirectSoundDevice *	device,
		IDirectSound3DListenerImpl **	pdsl
	)

Definition at line 1034 of file sound3d.c.

{
    IDirectSound3DListenerImpl *pdsl;
    TRACE("(%p,%p)\n",device,ppdsl);
 
    pdsl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*pdsl));
 
    if (pdsl == NULL) {
        WARN("out of memory\n");
        *ppdsl = 0;
        return DSERR_OUTOFMEMORY;
    }
 
    pdsl->ref = 0;
    pdsl->lpVtbl = &ds3dlvt;
 
    pdsl->device = device;
 
    pdsl->device->ds3dl.dwSize = sizeof(DS3DLISTENER);
    pdsl->device->ds3dl.vPosition.x = 0.0;
    pdsl->device->ds3dl.vPosition.y = 0.0;
    pdsl->device->ds3dl.vPosition.z = 0.0;
    pdsl->device->ds3dl.vVelocity.x = 0.0;
    pdsl->device->ds3dl.vVelocity.y = 0.0;
    pdsl->device->ds3dl.vVelocity.z = 0.0;
    pdsl->device->ds3dl.vOrientFront.x = 0.0;
    pdsl->device->ds3dl.vOrientFront.y = 0.0;
    pdsl->device->ds3dl.vOrientFront.z = 1.0;
    pdsl->device->ds3dl.vOrientTop.x = 0.0;
    pdsl->device->ds3dl.vOrientTop.y = 1.0;
    pdsl->device->ds3dl.vOrientTop.z = 0.0;
    pdsl->device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
    pdsl->device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
    pdsl->device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
 
    pdsl->device->ds3dl_need_recalc = TRUE;
 
    *ppdsl = pdsl;
    return S_OK;
}

Referenced by PrimaryBufferImpl_QueryInterface().

IDirectSoundBufferImpl_Create()

HRESULT IDirectSoundBufferImpl_Create	(	DirectSoundDevice *	device,
		IDirectSoundBufferImpl **	ppdsb,
		LPCDSBUFFERDESC	dsbd
	)

Definition at line 931 of file buffer.c.

{
    IDirectSoundBufferImpl *dsb;
    LPWAVEFORMATEX wfex = dsbd->lpwfxFormat;
    HRESULT err = DS_OK;
    DWORD capf = 0;
    int use_hw;
    TRACE("(%p,%p,%p)\n",device,pdsb,dsbd);
 
    if (dsbd->dwBufferBytes < DSBSIZE_MIN || dsbd->dwBufferBytes > DSBSIZE_MAX) {
        WARN("invalid parameter: dsbd->dwBufferBytes = %d\n", dsbd->dwBufferBytes);
        *pdsb = NULL;
        return DSERR_INVALIDPARAM; /* FIXME: which error? */
    }
 
    dsb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsb));
 
    if (dsb == 0) {
        WARN("out of memory\n");
        *pdsb = NULL;
        return DSERR_OUTOFMEMORY;
    }
 
    TRACE("Created buffer at %p\n", dsb);
 
        dsb->ref = 1;
        dsb->numIfaces = 1;
    dsb->device = device;
        dsb->IDirectSoundBuffer8_iface.lpVtbl = &dsbvt;
    dsb->iks = NULL;
 
    /* size depends on version */
    CopyMemory(&dsb->dsbd, dsbd, dsbd->dwSize);
 
    dsb->pwfx = DSOUND_CopyFormat(wfex);
    if (dsb->pwfx == NULL) {
        HeapFree(GetProcessHeap(),0,dsb);
        *pdsb = NULL;
        return DSERR_OUTOFMEMORY;
    }
 
    if (dsbd->dwBufferBytes % dsbd->lpwfxFormat->nBlockAlign)
        dsb->buflen = dsbd->dwBufferBytes + 
            (dsbd->lpwfxFormat->nBlockAlign - 
            (dsbd->dwBufferBytes % dsbd->lpwfxFormat->nBlockAlign));
    else
        dsb->buflen = dsbd->dwBufferBytes;
 
    dsb->freq = dsbd->lpwfxFormat->nSamplesPerSec;
    dsb->notify = NULL;
    dsb->notifies = NULL;
    dsb->nrofnotifies = 0;
    dsb->hwnotify = 0;
 
    /* Check necessary hardware mixing capabilities */
    if (wfex->nChannels==2) capf |= DSCAPS_SECONDARYSTEREO;
    else capf |= DSCAPS_SECONDARYMONO;
    if (wfex->wBitsPerSample==16) capf |= DSCAPS_SECONDARY16BIT;
    else capf |= DSCAPS_SECONDARY8BIT;
 
    use_hw = !!(dsbd->dwFlags & DSBCAPS_LOCHARDWARE);
    TRACE("use_hw = %d, capf = 0x%08x, device->drvcaps.dwFlags = 0x%08x\n", use_hw, capf, device->drvcaps.dwFlags);
    if (use_hw && ((device->drvcaps.dwFlags & capf) != capf || !device->driver))
    {
        if (device->driver)
            WARN("Format not supported for hardware buffer\n");
        HeapFree(GetProcessHeap(),0,dsb->pwfx);
        HeapFree(GetProcessHeap(),0,dsb);
        *pdsb = NULL;
        if ((device->drvcaps.dwFlags & capf) != capf)
            return DSERR_BADFORMAT;
        return DSERR_GENERIC;
    }
 
    /* FIXME: check hardware sample rate mixing capabilities */
    /* FIXME: check app hints for software/hardware buffer (STATIC, LOCHARDWARE, etc) */
    /* FIXME: check whether any hardware buffers are left */
    /* FIXME: handle DSDHEAP_CREATEHEAP for hardware buffers */
 
    /* Allocate an empty buffer */
    dsb->buffer = HeapAlloc(GetProcessHeap(),0,sizeof(*(dsb->buffer)));
    if (dsb->buffer == NULL) {
        WARN("out of memory\n");
        HeapFree(GetProcessHeap(),0,dsb->pwfx);
        HeapFree(GetProcessHeap(),0,dsb);
        *pdsb = NULL;
        return DSERR_OUTOFMEMORY;
    }
 
    /* Allocate system memory for buffer if applicable */
    if ((device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) || !use_hw) {
        dsb->buffer->memory = HeapAlloc(GetProcessHeap(),0,dsb->buflen);
        if (dsb->buffer->memory == NULL) {
            WARN("out of memory\n");
            HeapFree(GetProcessHeap(),0,dsb->pwfx);
            HeapFree(GetProcessHeap(),0,dsb->buffer);
            HeapFree(GetProcessHeap(),0,dsb);
            *pdsb = NULL;
            return DSERR_OUTOFMEMORY;
        }
    }
 
    /* Allocate the hardware buffer */
    if (use_hw) {
        err = IDsDriver_CreateSoundBuffer(device->driver,wfex,dsbd->dwFlags,0,
                          &(dsb->buflen),&(dsb->buffer->memory),
                          (LPVOID*)&(dsb->hwbuf));
        if (FAILED(err))
        {
            WARN("Failed to create hardware secondary buffer: %08x\n", err);
            if (device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY)
                HeapFree(GetProcessHeap(),0,dsb->buffer->memory);
            HeapFree(GetProcessHeap(),0,dsb->buffer);
            HeapFree(GetProcessHeap(),0,dsb->pwfx);
            HeapFree(GetProcessHeap(),0,dsb);
            *pdsb = NULL;
            return DSERR_GENERIC;
        }
    }
 
    dsb->buffer->ref = 1;
    list_init(&dsb->buffer->buffers);
    list_add_head(&dsb->buffer->buffers, &dsb->entry);
    FillMemory(dsb->buffer->memory, dsb->buflen, dsbd->lpwfxFormat->wBitsPerSample == 8 ? 128 : 0);
 
    /* It's not necessary to initialize values to zero since */
    /* we allocated this structure with HEAP_ZERO_MEMORY... */
    dsb->buf_mixpos = dsb->sec_mixpos = 0;
    dsb->state = STATE_STOPPED;
 
    dsb->freqAdjust = ((DWORD64)dsb->freq << DSOUND_FREQSHIFT) / device->pwfx->nSamplesPerSec;
    dsb->nAvgBytesPerSec = dsb->freq *
        dsbd->lpwfxFormat->nBlockAlign;
 
    /* calculate fragment size and write lead */
    DSOUND_RecalcFormat(dsb);
 
    if (dsb->dsbd.dwFlags & DSBCAPS_CTRL3D) {
        dsb->ds3db_ds3db.dwSize = sizeof(DS3DBUFFER);
        dsb->ds3db_ds3db.vPosition.x = 0.0;
        dsb->ds3db_ds3db.vPosition.y = 0.0;
        dsb->ds3db_ds3db.vPosition.z = 0.0;
        dsb->ds3db_ds3db.vVelocity.x = 0.0;
        dsb->ds3db_ds3db.vVelocity.y = 0.0;
        dsb->ds3db_ds3db.vVelocity.z = 0.0;
        dsb->ds3db_ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
        dsb->ds3db_ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
        dsb->ds3db_ds3db.vConeOrientation.x = 0.0;
        dsb->ds3db_ds3db.vConeOrientation.y = 0.0;
        dsb->ds3db_ds3db.vConeOrientation.z = 0.0;
        dsb->ds3db_ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
        dsb->ds3db_ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
        dsb->ds3db_ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
        dsb->ds3db_ds3db.dwMode = DS3DMODE_NORMAL;
 
        dsb->ds3db_need_recalc = FALSE;
        DSOUND_Calc3DBuffer(dsb);
    } else
        DSOUND_RecalcVolPan(&(dsb->volpan));
 
    RtlInitializeResource(&dsb->lock);
 
    /* register buffer if not primary */
    if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
        err = DirectSoundDevice_AddBuffer(device, dsb);
        if (err != DS_OK) {
            HeapFree(GetProcessHeap(),0,dsb->buffer->memory);
            HeapFree(GetProcessHeap(),0,dsb->buffer);
            RtlDeleteResource(&dsb->lock);
            HeapFree(GetProcessHeap(),0,dsb->pwfx);
            HeapFree(GetProcessHeap(),0,dsb);
            dsb = NULL;
        }
    }
 
    *pdsb = dsb;
    return err;
}

Referenced by DirectSoundDevice_CreateSoundBuffer().

IDirectSoundBufferImpl_Destroy()

HRESULT IDirectSoundBufferImpl_Destroy

(

IDirectSoundBufferImpl *

pdsb

)

Definition at line 1137 of file buffer.c.

{
    TRACE("(%p)\n",pdsb);
 
    /* This keeps the *_Destroy functions from possibly deleting
     * this object until it is ready to be deleted */
    InterlockedIncrement(&pdsb->numIfaces);
 
    if (pdsb->iks) {
        WARN("iks not NULL\n");
        IKsBufferPropertySetImpl_Destroy(pdsb->iks);
        pdsb->iks = NULL;
    }
 
    if (pdsb->ds3db) {
        WARN("ds3db not NULL\n");
        IDirectSound3DBufferImpl_Destroy(pdsb->ds3db);
        pdsb->ds3db = NULL;
    }
 
    if (pdsb->notify) {
        WARN("notify not NULL\n");
        IDirectSoundNotifyImpl_Destroy(pdsb->notify);
        pdsb->notify = NULL;
    }
 
    secondarybuffer_destroy(pdsb);
 
    return S_OK;
}

Referenced by DirectSoundDevice_Release().

IDirectSoundBufferImpl_Duplicate()

HRESULT IDirectSoundBufferImpl_Duplicate	(	DirectSoundDevice *	device,
		IDirectSoundBufferImpl **	ppdsb,
		IDirectSoundBufferImpl *	pdsb
	)

Definition at line 1169 of file buffer.c.

{
    IDirectSoundBufferImpl *dsb;
    HRESULT hres = DS_OK;
    TRACE("(%p,%p,%p)\n", device, ppdsb, pdsb);
 
    dsb = HeapAlloc(GetProcessHeap(),0,sizeof(*dsb));
    if (dsb == NULL) {
        WARN("out of memory\n");
        *ppdsb = NULL;
        return DSERR_OUTOFMEMORY;
    }
    CopyMemory(dsb, pdsb, sizeof(*dsb));
 
    dsb->pwfx = DSOUND_CopyFormat(pdsb->pwfx);
    if (dsb->pwfx == NULL) {
        HeapFree(GetProcessHeap(),0,dsb);
        *ppdsb = NULL;
        return DSERR_OUTOFMEMORY;
    }
 
    if (pdsb->hwbuf) {
        TRACE("duplicating hardware buffer\n");
 
        hres = IDsDriver_DuplicateSoundBuffer(device->driver, pdsb->hwbuf,
                                              (LPVOID *)&dsb->hwbuf);
        if (FAILED(hres)) {
            WARN("IDsDriver_DuplicateSoundBuffer failed (%08x)\n", hres);
            HeapFree(GetProcessHeap(),0,dsb->pwfx);
            HeapFree(GetProcessHeap(),0,dsb);
            *ppdsb = NULL;
            return hres;
        }
    }
 
    dsb->buffer->ref++;
    list_add_head(&dsb->buffer->buffers, &dsb->entry);
    dsb->ref = 1;
    dsb->numIfaces = 1;
    dsb->state = STATE_STOPPED;
    dsb->buf_mixpos = dsb->sec_mixpos = 0;
    dsb->notify = NULL;
    dsb->notifies = NULL;
    dsb->nrofnotifies = 0;
    dsb->device = device;
    dsb->ds3db = NULL;
    dsb->iks = NULL; /* FIXME? */
    dsb->tmp_buffer = NULL;
    DSOUND_RecalcFormat(dsb);
    DSOUND_MixToTemporary(dsb, 0, dsb->buflen, FALSE);
 
    RtlInitializeResource(&dsb->lock);
 
    /* register buffer */
    hres = DirectSoundDevice_AddBuffer(device, dsb);
    if (hres != DS_OK) {
        RtlDeleteResource(&dsb->lock);
        HeapFree(GetProcessHeap(),0,dsb->tmp_buffer);
        list_remove(&dsb->entry);
        dsb->buffer->ref--;
        HeapFree(GetProcessHeap(),0,dsb->pwfx);
        HeapFree(GetProcessHeap(),0,dsb);
        dsb = NULL;
    }
 
    *ppdsb = dsb;
    return hres;
}

Referenced by DirectSoundDevice_DuplicateSoundBuffer().

IKsBufferPropertySetImpl_Create()

HRESULT IKsBufferPropertySetImpl_Create	(	IDirectSoundBufferImpl *	dsb,
		IKsBufferPropertySetImpl **	piks
	)

Definition at line 1390 of file buffer.c.

{
    IKsBufferPropertySetImpl *iks;
    TRACE("(%p,%p)\n",dsb,piks);
    *piks = NULL;
 
    iks = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*iks));
    if (iks == 0) {
        WARN("out of memory\n");
        *piks = NULL;
        return DSERR_OUTOFMEMORY;
    }
 
    iks->ref = 0;
    iks->dsb = dsb;
    dsb->iks = iks;
    iks->lpVtbl = &iksbvt;
 
    IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)dsb);
 
    *piks = iks;
    return S_OK;
}

Referenced by IDirectSoundBufferImpl_QueryInterface().

IKsBufferPropertySetImpl_Destroy()

HRESULT IKsBufferPropertySetImpl_Destroy

(

IKsBufferPropertySetImpl *

piks

)

Definition at line 1416 of file buffer.c.

{
    TRACE("(%p)\n",piks);
 
    while (IKsBufferPropertySetImpl_Release((LPKSPROPERTYSET)piks) > 0);
 
    return S_OK;
}

Referenced by IDirectSoundBufferImpl_Destroy().

IKsPrivatePropertySetImpl_Create()

HRESULT IKsPrivatePropertySetImpl_Create	(	REFIID	riid,
		IKsPropertySet **	piks
	)

Definition at line 615 of file propset.c.

{
    IKsPrivatePropertySetImpl *iks;
    TRACE("(%s, %p)\n", debugstr_guid(riid), piks);
 
    if (!IsEqualIID(riid, &IID_IUnknown) &&
        !IsEqualIID(riid, &IID_IKsPropertySet)) {
        *piks = 0;
        return E_NOINTERFACE;
    }
 
    iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
    iks->ref = 1;
    iks->IKsPropertySet_iface.lpVtbl = &ikspvt;
 
    *piks = &iks->IKsPropertySet_iface;
    return S_OK;
}

mmErr()

HRESULT mmErr

(

UINT

err

)

Definition at line 44 of file dsound_main.c.

{
    switch(err) {
    case MMSYSERR_NOERROR:
        return DS_OK;
    case MMSYSERR_ALLOCATED:
        return DSERR_ALLOCATED;
    case MMSYSERR_ERROR:
    case MMSYSERR_INVALHANDLE:
    case WAVERR_STILLPLAYING:
        return DSERR_GENERIC; /* FIXME */
    case MMSYSERR_BADDEVICEID:
    case MMSYSERR_NODRIVER:
        return DSERR_NODRIVER;
    case MMSYSERR_NOMEM:
        return DSERR_OUTOFMEMORY;
    case MMSYSERR_INVALPARAM:
    case WAVERR_BADFORMAT:
    case WAVERR_UNPREPARED:
        return DSERR_INVALIDPARAM;
    case MMSYSERR_NOTSUPPORTED:
        return DSERR_UNSUPPORTED;
    default:
        FIXME("Unknown MMSYS error %d\n",err);
        return DSERR_GENERIC;
    }
}

Referenced by DirectSoundCaptureDevice_Initialize(), DirectSoundCaptureEnumerateW(), DirectSoundDevice_Initialize(), DirectSoundEnumerateW(), DSOUND_PrimaryOpen(), DSOUND_PrimaryPlay(), DSOUND_PrimaryStop(), DSOUND_ReopenDevice(), IDirectSoundCaptureBufferImpl_Create(), IDirectSoundCaptureBufferImpl_Start(), and IDirectSoundCaptureBufferImpl_Stop().

primarybuffer_create()

HRESULT primarybuffer_create	(	DirectSoundDevice *	device,
		IDirectSoundBufferImpl **	ppdsb,
		const DSBUFFERDESC *	dsbd
	)

Definition at line 1223 of file primary.c.

{
    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 = 1;
        dsb->numIfaces = 1;
    dsb->device = device;
    dsb->IDirectSoundBuffer8_iface.lpVtbl = (IDirectSoundBuffer8Vtbl *)&dspbvt;
    dsb->dsbd = *dsbd;
 
    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);
 
    *ppdsb = dsb;
    return S_OK;
}

Referenced by DirectSoundDevice_CreateSoundBuffer().

primarybuffer_destroy()

void primarybuffer_destroy

(

IDirectSoundBufferImpl *

This

)

Definition at line 763 of file primary.c.

{
    This->device->primary = NULL;
    HeapFree(GetProcessHeap(), 0, This);
    TRACE("(%p) released\n", This);
}

Referenced by IDirectSound3DListenerImpl_Release(), IDirectSoundBufferImpl_Release(), and PrimaryBufferImpl_Release().

primarybuffer_SetFormat()

HRESULT primarybuffer_SetFormat	(	DirectSoundDevice *	device,
		LPCWAVEFORMATEX	wfex
	)

Definition at line 460 of file primary.c.

{
    HRESULT err = DSERR_BUFFERLOST;
    int i;
    DWORD nSamplesPerSec, bpp, chans;
    LPWAVEFORMATEX oldpwfx;
        BOOL forced = device->priolevel == DSSCL_WRITEPRIMARY;
 
    TRACE("(%p,%p)\n", device, wfex);
 
    if (device->priolevel == DSSCL_NORMAL) {
        WARN("failed priority check!\n");
        return DSERR_PRIOLEVELNEEDED;
    }
 
    /* Let's be pedantic! */
    if (wfex == NULL) {
        WARN("invalid parameter: wfex==NULL!\n");
        return DSERR_INVALIDPARAM;
    }
    TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
              "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
          wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
          wfex->nAvgBytesPerSec, wfex->nBlockAlign,
          wfex->wBitsPerSample, wfex->cbSize);
 
    /* **** */
    RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
    EnterCriticalSection(&(device->mixlock));
 
    nSamplesPerSec = device->pwfx->nSamplesPerSec;
    bpp = device->pwfx->wBitsPerSample;
    chans = device->pwfx->nChannels;
 
    oldpwfx = device->pwfx;
    device->pwfx = DSOUND_CopyFormat(wfex);
    if (device->pwfx == NULL) {
        device->pwfx = oldpwfx;
        oldpwfx = NULL;
        err = DSERR_OUTOFMEMORY;
        goto done;
    }
 
    if (!(device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMSETFORMAT) && device->hwbuf) {
        err = IDsDriverBuffer_SetFormat(device->hwbuf, device->pwfx);
 
        /* On bad format, try to re-create, big chance it will work then, only do this if we <HAVE> to */
        if (forced && (device->pwfx->nSamplesPerSec/100 != wfex->nSamplesPerSec/100 || err == DSERR_BADFORMAT))
        {
            DWORD cp_size = wfex->wFormatTag == WAVE_FORMAT_PCM ?
                sizeof(PCMWAVEFORMAT) : sizeof(WAVEFORMATEX) + wfex->cbSize;
            err = DSERR_BUFFERLOST;
            CopyMemory(device->pwfx, wfex, cp_size);
        }
 
        if (err != DSERR_BUFFERLOST && FAILED(err)) {
            DWORD size = DSOUND_GetFormatSize(oldpwfx);
            WARN("IDsDriverBuffer_SetFormat failed\n");
            if (!forced) {
                CopyMemory(device->pwfx, oldpwfx, size);
                err = DS_OK;
            }
            goto done;
        }
 
        if (err == S_FALSE)
        {
            /* ALSA specific: S_FALSE tells that recreation was successful,
             * but size and location may be changed, and buffer has to be restarted
             * I put it here, so if frequency doesn't match the error will be changed to DSERR_BUFFERLOST
             * and the entire re-initialization will occur anyway
             */
            IDsDriverBuffer_Lock(device->hwbuf, (LPVOID *)&device->buffer, &device->buflen, NULL, NULL, 0, 0, DSBLOCK_ENTIREBUFFER);
            IDsDriverBuffer_Unlock(device->hwbuf, device->buffer, 0, NULL, 0);
 
            if (device->state == STATE_PLAYING) device->state = STATE_STARTING;
            else if (device->state == STATE_STOPPING) device->state = STATE_STOPPED;
            device->pwplay = device->pwqueue = device->playpos = device->mixpos = 0;
            err = DS_OK;
        }
        DSOUND_RecalcPrimary(device);
    }
 
    if (err == DSERR_BUFFERLOST)
    {
        DSOUND_PrimaryClose(device);
 
        err = DSOUND_ReopenDevice(device, FALSE);
        if (FAILED(err))
        {
            WARN("DSOUND_ReopenDevice failed: %08x\n", err);
            goto done;
        }
        err = DSOUND_PrimaryOpen(device);
        if (err != DS_OK) {
            WARN("DSOUND_PrimaryOpen failed\n");
            goto done;
        }
 
        if (wfex->nSamplesPerSec/100 != device->pwfx->nSamplesPerSec/100 && forced && device->buffer)
        {
            DSOUND_PrimaryClose(device);
            device->pwfx->nSamplesPerSec = wfex->nSamplesPerSec;
            err = DSOUND_ReopenDevice(device, TRUE);
            if (FAILED(err))
                WARN("DSOUND_ReopenDevice(2) failed: %08x\n", err);
            else if (FAILED((err = DSOUND_PrimaryOpen(device))))
                WARN("DSOUND_PrimaryOpen(2) failed: %08x\n", err);
        }
    }
 
    device->mix_buffer_len = DSOUND_bufpos_to_mixpos(device, device->buflen);
    device->mix_buffer = HeapReAlloc(GetProcessHeap(), 0, device->mix_buffer, device->mix_buffer_len);
    FillMemory(device->mix_buffer, device->mix_buffer_len, 0);
    device->mixfunction = mixfunctions[device->pwfx->wBitsPerSample/8 - 1];
    device->normfunction = normfunctions[device->pwfx->wBitsPerSample/8 - 1];
 
    if (nSamplesPerSec != device->pwfx->nSamplesPerSec || bpp != device->pwfx->wBitsPerSample || chans != device->pwfx->nChannels) {
        IDirectSoundBufferImpl** dsb = device->buffers;
        for (i = 0; i < device->nrofbuffers; i++, dsb++) {
            /* **** */
            RtlAcquireResourceExclusive(&(*dsb)->lock, TRUE);
 
            (*dsb)->freqAdjust = ((DWORD64)(*dsb)->freq << DSOUND_FREQSHIFT) / device->pwfx->nSamplesPerSec;
            DSOUND_RecalcFormat((*dsb));
            DSOUND_MixToTemporary((*dsb), 0, (*dsb)->buflen, FALSE);
            (*dsb)->primary_mixpos = 0;
 
            RtlReleaseResource(&(*dsb)->lock);
            /* **** */
        }
    }
 
done:
    LeaveCriticalSection(&(device->mixlock));
    RtlReleaseResource(&(device->buffer_list_lock));
    /* **** */
 
    HeapFree(GetProcessHeap(), 0, oldpwfx);
    return err;
}

Referenced by IDirectSoundBufferImpl_SetFormat(), and PrimaryBufferImpl_SetFormat().

secondarybuffer_destroy()

void secondarybuffer_destroy

(

IDirectSoundBufferImpl *

This

)

Definition at line 1113 of file buffer.c.

{
    DirectSoundDevice_RemoveBuffer(This->device, This);
    RtlDeleteResource(&This->lock);
 
    if (This->hwbuf)
        IDsDriverBuffer_Release(This->hwbuf);
    if (!This->hwbuf || (This->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY)) {
        This->buffer->ref--;
        list_remove(&This->entry);
        if (This->buffer->ref == 0) {
            HeapFree(GetProcessHeap(), 0, This->buffer->memory);
            HeapFree(GetProcessHeap(), 0, This->buffer);
        }
    }
 
    HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
    HeapFree(GetProcessHeap(), 0, This->notifies);
    HeapFree(GetProcessHeap(), 0, This->pwfx);
    HeapFree(GetProcessHeap(), 0, This);
 
    TRACE("(%p) released\n", This);
}

Referenced by IDirectSound3DBufferImpl_Release(), IDirectSoundBufferImpl_Destroy(), and IDirectSoundBufferImpl_Release().

setup_dsound_options()

void setup_dsound_options

(

void

)

Definition at line 102 of file dsound_main.c.

{
    char buffer[MAX_PATH+16];
    HKEY hkey, appkey = 0;
    DWORD len;
 
    buffer[MAX_PATH]='\0';
 
    /* @@ Wine registry key: HKCU\Software\Wine\DirectSound */
    if (RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\DirectSound", &hkey )) hkey = 0;
 
    len = GetModuleFileNameA( 0, buffer, MAX_PATH );
    if (len && len < MAX_PATH)
    {
        HKEY tmpkey;
        /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\DirectSound */
        if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\AppDefaults", &tmpkey ))
        {
            char *p, *appname = buffer;
            if ((p = strrchr( appname, '/' ))) appname = p + 1;
            if ((p = strrchr( appname, '\\' ))) appname = p + 1;
            strcat( appname, "\\DirectSound" );
            TRACE("appname = [%s]\n", appname);
            if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0;
            RegCloseKey( tmpkey );
        }
    }
 
    /* get options */
 
    if (!get_config_key( hkey, appkey, "EmulDriver", buffer, MAX_PATH ))
        ds_emuldriver = strcmp(buffer, "N");
 
    if (!get_config_key( hkey, appkey, "HelBuflen", buffer, MAX_PATH ))
        ds_hel_buflen = atoi(buffer);
 
    if (!get_config_key( hkey, appkey, "SndQueueMax", buffer, MAX_PATH ))
        ds_snd_queue_max = atoi(buffer);
 
    if (!get_config_key( hkey, appkey, "SndQueueMin", buffer, MAX_PATH ))
        ds_snd_queue_min = atoi(buffer);
 
    if (!get_config_key( hkey, appkey, "HardwareAcceleration", buffer, MAX_PATH )) {
    if (strcmp(buffer, "Full") == 0)
        ds_hw_accel = DS_HW_ACCEL_FULL;
    else if (strcmp(buffer, "Standard") == 0)
        ds_hw_accel = DS_HW_ACCEL_STANDARD;
    else if (strcmp(buffer, "Basic") == 0)
        ds_hw_accel = DS_HW_ACCEL_BASIC;
    else if (strcmp(buffer, "Emulation") == 0)
        ds_hw_accel = DS_HW_ACCEL_EMULATION;
    }
 
    if (!get_config_key( hkey, appkey, "DefaultPlayback", buffer, MAX_PATH ))
        ds_default_playback = atoi(buffer);
 
    if (!get_config_key( hkey, appkey, "MaxShadowSize", buffer, MAX_PATH ))
        ds_snd_shadow_maxsize = atoi(buffer);
 
    if (!get_config_key( hkey, appkey, "DefaultCapture", buffer, MAX_PATH ))
        ds_default_capture = atoi(buffer);
 
    if (!get_config_key( hkey, appkey, "DefaultSampleRate", buffer, MAX_PATH ))
        ds_default_sample_rate = atoi(buffer);
 
    if (!get_config_key( hkey, appkey, "DefaultBitsPerSample", buffer, MAX_PATH ))
        ds_default_bits_per_sample = atoi(buffer);
 
    if (appkey) RegCloseKey( appkey );
    if (hkey) RegCloseKey( hkey );
 
    TRACE("ds_emuldriver = %d\n", ds_emuldriver);
    TRACE("ds_hel_buflen = %d\n", ds_hel_buflen);
    TRACE("ds_snd_queue_max = %d\n", ds_snd_queue_max);
    TRACE("ds_snd_queue_min = %d\n", ds_snd_queue_min);
    TRACE("ds_hw_accel = %s\n",
        ds_hw_accel==DS_HW_ACCEL_FULL ? "Full" :
        ds_hw_accel==DS_HW_ACCEL_STANDARD ? "Standard" :
        ds_hw_accel==DS_HW_ACCEL_BASIC ? "Basic" :
        ds_hw_accel==DS_HW_ACCEL_EMULATION ? "Emulation" :
        "Unknown");
    TRACE("ds_default_playback = %d\n", ds_default_playback);
    TRACE("ds_default_capture = %d\n", ds_default_playback);
    TRACE("ds_default_sample_rate = %d\n", ds_default_sample_rate);
    TRACE("ds_default_bits_per_sample = %d\n", ds_default_bits_per_sample);
    TRACE("ds_snd_shadow_maxsize = %d\n", ds_snd_shadow_maxsize);
}

Referenced by DirectSoundCaptureEnumerateW(), DirectSoundEnumerateW(), DSOUND_CaptureCreate(), DSOUND_CaptureCreate8(), DSOUND_Create(), DSOUND_Create8(), DSOUND_FullDuplexCreate(), and DSPROPERTY_DescriptionW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dsound

)

Variable Documentation

DECLSPEC_HIDDEN

GUID DSOUND_capture_guids [MAXWAVEDRIVERS] DECLSPEC_HIDDEN

extern

Definition at line 68 of file dsound_private.h.