mirror of
https://github.com/reactos/wine.git
synced 2024-12-07 19:37:28 +00:00
1992 lines
51 KiB
C
1992 lines
51 KiB
C
/* DirectSound
|
|
*
|
|
* Copyright 1998 Marcus Meissner
|
|
* Copyright 1998 Rob Riggs
|
|
*/
|
|
/*
|
|
* Note: This file requires multithread ability. It is not possible to
|
|
* implement the stuff in a single thread anyway. And most DirectX apps
|
|
* require threading themselves.
|
|
*
|
|
* FIXME: This file is full of race conditions and unlocked variable access
|
|
* from two threads. But we usually don't need to bother.
|
|
*
|
|
* Tested with a Soundblaster clone and a Gravis UltraSound Classic.
|
|
*
|
|
* Status:
|
|
* - Wing Commander 4/W95:
|
|
* The intromovie plays without problems. Nearly lipsynchron.
|
|
* - DiscWorld 2
|
|
* The sound works, but noticeable chunks are left out (from the sound and
|
|
* the animation). Don't know why yet.
|
|
* - Diablo:
|
|
* Sound works, but slows down the movieplayer.
|
|
* - XvT:
|
|
* Doesn't sound yet.
|
|
* - Monkey Island 3:
|
|
* The background sound of the startscreen works ;)
|
|
* - WingCommander Prophecy Demo:
|
|
* Sound works for the intromovie.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/fcntl.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h> /* Insomnia - pow() function */
|
|
#include "windows.h"
|
|
#include "winerror.h"
|
|
#include "interfaces.h"
|
|
#include "mmsystem.h"
|
|
#include "dsound.h"
|
|
#include "thread.h"
|
|
#include "debug.h"
|
|
#include "xmalloc.h"
|
|
|
|
#ifdef HAVE_OSS
|
|
# include <sys/ioctl.h>
|
|
# ifdef HAVE_MACHINE_SOUNDCARD_H
|
|
# include <machine/soundcard.h>
|
|
# endif
|
|
# ifdef HAVE_SYS_SOUNDCARD_H
|
|
# include <sys/soundcard.h>
|
|
# endif
|
|
|
|
/* #define USE_DSOUND3D 1 */
|
|
|
|
static int audiofd = -1;
|
|
static int audioOK = 0;
|
|
|
|
static LPDIRECTSOUND dsound = NULL;
|
|
|
|
static LPDIRECTSOUNDBUFFER primarybuf = NULL;
|
|
|
|
static int DSOUND_setformat(LPWAVEFORMATEX wfex);
|
|
static void DSOUND_CloseAudio(void);
|
|
|
|
#endif
|
|
|
|
HRESULT WINAPI DirectSoundEnumerate32A(LPDSENUMCALLBACK32A enumcb,LPVOID context) {
|
|
#ifdef HAVE_OSS
|
|
enumcb(NULL,"WINE DirectSound using Open Sound System","sound",context);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#ifdef HAVE_OSS
|
|
static void _dump_DSBCAPS(DWORD xmask) {
|
|
struct {
|
|
DWORD mask;
|
|
char *name;
|
|
} flags[] = {
|
|
#define FE(x) { x, #x },
|
|
FE(DSBCAPS_PRIMARYBUFFER)
|
|
FE(DSBCAPS_STATIC)
|
|
FE(DSBCAPS_LOCHARDWARE)
|
|
FE(DSBCAPS_LOCSOFTWARE)
|
|
FE(DSBCAPS_CTRLFREQUENCY)
|
|
FE(DSBCAPS_CTRLPAN)
|
|
FE(DSBCAPS_CTRLVOLUME)
|
|
FE(DSBCAPS_CTRLDEFAULT)
|
|
FE(DSBCAPS_CTRLALL)
|
|
FE(DSBCAPS_STICKYFOCUS)
|
|
FE(DSBCAPS_GETCURRENTPOSITION2)
|
|
};
|
|
int i;
|
|
|
|
for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
|
|
if (flags[i].mask & xmask)
|
|
fprintf(stderr,"%s ",flags[i].name);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* IDirectSound3DBuffer
|
|
*/
|
|
|
|
// IUnknown methods
|
|
static HRESULT WINAPI IDirectSound3DBuffer_QueryInterface(
|
|
LPDIRECTSOUND3DBUFFER this, REFIID riid, LPVOID *ppobj)
|
|
{
|
|
char xbuf[50];
|
|
|
|
WINE_StringFromCLSID(riid,xbuf);
|
|
TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
|
|
return E_FAIL;
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSound3DBuffer_AddRef(LPDIRECTSOUND3DBUFFER this)
|
|
{
|
|
this->ref++;
|
|
return this->ref;
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSound3DBuffer_Release(LPDIRECTSOUND3DBUFFER this)
|
|
{
|
|
if(--this->ref)
|
|
return this->ref;
|
|
|
|
HeapFree(GetProcessHeap(),0,this->buffer);
|
|
HeapFree(GetProcessHeap(),0,this);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// IDirectSound3DBuffer methods
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetAllParameters(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPDS3DBUFFER lpDs3dBuffer)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetConeAngles(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPDWORD lpdwInsideConeAngle,
|
|
LPDWORD lpdwOutsideConeAngle)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetConeOrientation(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPD3DVECTOR lpvConeOrientation)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetConeOutsideVolume(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPLONG lplConeOutsideVolume)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetMaxDistance(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPD3DVALUE lpfMaxDistance)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetMinDistance(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPD3DVALUE lpfMinDistance)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetMode(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPDWORD lpdwMode)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetPosition(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPD3DVECTOR lpvPosition)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_GetVelocity(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPD3DVECTOR lpvVelocity)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetAllParameters(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LPCDS3DBUFFER lpcDs3dBuffer,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetConeAngles(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
DWORD dwInsideConeAngle,
|
|
DWORD dwOutsideConeAngle,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetConeOrientation(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
D3DVALUE x, D3DVALUE y, D3DVALUE z,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetConeOutsideVolume(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
LONG lConeOutsideVolume,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetMaxDistance(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
D3DVALUE fMaxDistance,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetMinDistance(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
D3DVALUE fMinDistance,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetMode(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
DWORD dwMode,
|
|
DWORD dwApply)
|
|
{
|
|
TRACE(dsound, "mode = %lx\n", dwMode);
|
|
this->ds3db.dwMode = dwMode;
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetPosition(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
D3DVALUE x, D3DVALUE y, D3DVALUE z,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DBuffer_SetVelocity(
|
|
LPDIRECTSOUND3DBUFFER this,
|
|
D3DVALUE x, D3DVALUE y, D3DVALUE z,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
IDirectSound3DBuffer_VTable ds3dbvt = {
|
|
// IUnknown methods
|
|
IDirectSound3DBuffer_QueryInterface,
|
|
IDirectSound3DBuffer_AddRef,
|
|
IDirectSound3DBuffer_Release,
|
|
// IDirectSound3DBuffer methods
|
|
IDirectSound3DBuffer_GetAllParameters,
|
|
IDirectSound3DBuffer_GetConeAngles,
|
|
IDirectSound3DBuffer_GetConeOrientation,
|
|
IDirectSound3DBuffer_GetConeOutsideVolume,
|
|
IDirectSound3DBuffer_GetMaxDistance,
|
|
IDirectSound3DBuffer_GetMinDistance,
|
|
IDirectSound3DBuffer_GetMode,
|
|
IDirectSound3DBuffer_GetPosition,
|
|
IDirectSound3DBuffer_GetVelocity,
|
|
IDirectSound3DBuffer_SetAllParameters,
|
|
IDirectSound3DBuffer_SetConeAngles,
|
|
IDirectSound3DBuffer_SetConeOrientation,
|
|
IDirectSound3DBuffer_SetConeOutsideVolume,
|
|
IDirectSound3DBuffer_SetMaxDistance,
|
|
IDirectSound3DBuffer_SetMinDistance,
|
|
IDirectSound3DBuffer_SetMode,
|
|
IDirectSound3DBuffer_SetPosition,
|
|
IDirectSound3DBuffer_SetVelocity,
|
|
};
|
|
|
|
#ifdef USE_DSOUND3D
|
|
static int DSOUND_Create3DBuffer(LPDIRECTSOUNDBUFFER dsb)
|
|
{
|
|
DWORD i, temp, iSize, oSize, offset;
|
|
LPBYTE bIbuf, bObuf, bTbuf = NULL;
|
|
LPWORD wIbuf, wObuf, wTbuf = NULL;
|
|
|
|
// Inside DirectX says it's stupid but allowed
|
|
if (dsb->wfx.nChannels == 2) {
|
|
// Convert to mono
|
|
if (dsb->wfx.wBitsPerSample == 16) {
|
|
iSize = dsb->buflen / 4;
|
|
wTbuf = malloc(dsb->buflen / 2);
|
|
if (wTbuf == NULL)
|
|
return DSERR_OUTOFMEMORY;
|
|
for (i = 0; i < iSize; i++)
|
|
wTbuf[i] = (dsb->buffer[i] + dsb->buffer[(i * 2) + 1]) / 2;
|
|
wIbuf = wTbuf;
|
|
} else {
|
|
iSize = dsb->buflen / 2;
|
|
bTbuf = malloc(dsb->buflen / 2);
|
|
if (bTbuf == NULL)
|
|
return DSERR_OUTOFMEMORY;
|
|
for (i = 0; i < iSize; i++)
|
|
bTbuf[i] = (dsb->buffer[i] + dsb->buffer[(i * 2) + 1]) / 2;
|
|
bIbuf = bTbuf;
|
|
}
|
|
} else {
|
|
if (dsb->wfx.wBitsPerSample == 16) {
|
|
iSize = dsb->buflen / 2;
|
|
wIbuf = (LPWORD) dsb->buffer;
|
|
} else {
|
|
bIbuf = (LPBYTE) dsb->buffer;
|
|
iSize = dsb->buflen;
|
|
}
|
|
}
|
|
|
|
if (primarybuf->wfx.wBitsPerSample == 16) {
|
|
wObuf = (LPWORD) dsb->ds3db->buffer;
|
|
oSize = dsb->ds3db->buflen / 2;
|
|
} else {
|
|
bObuf = (LPBYTE) dsb->ds3db->buffer;
|
|
oSize = dsb->ds3db->buflen;
|
|
}
|
|
|
|
offset = primarybuf->wfx.nSamplesPerSec / 100; // 10ms
|
|
if (primarybuf->wfx.wBitsPerSample == 16 && dsb->wfx.wBitsPerSample == 16)
|
|
for (i = 0; i < iSize; i++) {
|
|
temp = wIbuf[i];
|
|
if (i >= offset)
|
|
temp += wIbuf[i - offset] >> 9;
|
|
else
|
|
temp += wIbuf[i + iSize - offset] >> 9;
|
|
wObuf[i * 2] = temp;
|
|
wObuf[(i * 2) + 1] = temp;
|
|
}
|
|
else if (primarybuf->wfx.wBitsPerSample == 8 && dsb->wfx.wBitsPerSample == 8)
|
|
for (i = 0; i < iSize; i++) {
|
|
temp = bIbuf[i];
|
|
if (i >= offset)
|
|
temp += bIbuf[i - offset] >> 5;
|
|
else
|
|
temp += bIbuf[i + iSize - offset] >> 5;
|
|
bObuf[i * 2] = temp;
|
|
bObuf[(i * 2) + 1] = temp;
|
|
}
|
|
|
|
if (wTbuf)
|
|
free(wTbuf);
|
|
if (bTbuf)
|
|
free(bTbuf);
|
|
|
|
return DS_OK;
|
|
}
|
|
#endif
|
|
/*******************************************************************************
|
|
* IDirectSound3DListener
|
|
*/
|
|
|
|
// IUnknown methods
|
|
static HRESULT WINAPI IDirectSound3DListener_QueryInterface(
|
|
LPDIRECTSOUND3DLISTENER this, REFIID riid, LPVOID *ppobj)
|
|
{
|
|
char xbuf[50];
|
|
|
|
WINE_StringFromCLSID(riid,xbuf);
|
|
TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
|
|
return E_FAIL;
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSound3DListener_AddRef(LPDIRECTSOUND3DLISTENER this)
|
|
{
|
|
this->ref++;
|
|
return this->ref;
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSound3DListener_Release(LPDIRECTSOUND3DLISTENER this)
|
|
{
|
|
this->ref--;
|
|
return this->ref;
|
|
}
|
|
|
|
// IDirectSound3DListener methods
|
|
static HRESULT WINAPI IDirectSound3DListener_GetAllParameter(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPDS3DLISTENER lpDS3DL)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_GetDistanceFactor(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPD3DVALUE lpfDistanceFactor)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_GetDopplerFactor(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPD3DVALUE lpfDopplerFactor)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_GetOrientation(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPD3DVECTOR lpvOrientFront,
|
|
LPD3DVECTOR lpvOrientTop)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_GetPosition(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPD3DVECTOR lpvPosition)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_GetRolloffFactor(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPD3DVALUE lpfRolloffFactor)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_GetVelocity(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPD3DVECTOR lpvVelocity)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_SetAllParameters(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
LPCDS3DLISTENER lpcDS3DL,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_SetDistanceFactor(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
D3DVALUE fDistanceFactor,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_SetDopplerFactor(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
D3DVALUE fDopplerFactor,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_SetOrientation(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
D3DVALUE xFront, D3DVALUE yFront, D3DVALUE zFront,
|
|
D3DVALUE xTop, D3DVALUE yTop, D3DVALUE zTop,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_SetPosition(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
D3DVALUE x, D3DVALUE y, D3DVALUE z,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_SetRolloffFactor(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
D3DVALUE fRolloffFactor,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_SetVelocity(
|
|
LPDIRECTSOUND3DLISTENER this,
|
|
D3DVALUE x, D3DVALUE y, D3DVALUE z,
|
|
DWORD dwApply)
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound3DListener_CommitDeferredSettings(
|
|
LPDIRECTSOUND3DLISTENER this)
|
|
|
|
{
|
|
FIXME(dsound,"stub\n");
|
|
return DS_OK;
|
|
}
|
|
|
|
IDirectSound3DListener_VTable ds3dlvt = {
|
|
// IUnknown methods
|
|
IDirectSound3DListener_QueryInterface,
|
|
IDirectSound3DListener_AddRef,
|
|
IDirectSound3DListener_Release,
|
|
// IDirectSound3DListener methods
|
|
IDirectSound3DListener_GetAllParameter,
|
|
IDirectSound3DListener_GetDistanceFactor,
|
|
IDirectSound3DListener_GetDopplerFactor,
|
|
IDirectSound3DListener_GetOrientation,
|
|
IDirectSound3DListener_GetPosition,
|
|
IDirectSound3DListener_GetRolloffFactor,
|
|
IDirectSound3DListener_GetVelocity,
|
|
IDirectSound3DListener_SetAllParameters,
|
|
IDirectSound3DListener_SetDistanceFactor,
|
|
IDirectSound3DListener_SetDopplerFactor,
|
|
IDirectSound3DListener_SetOrientation,
|
|
IDirectSound3DListener_SetPosition,
|
|
IDirectSound3DListener_SetRolloffFactor,
|
|
IDirectSound3DListener_SetVelocity,
|
|
IDirectSound3DListener_CommitDeferredSettings,
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* IDirectSoundNotify
|
|
*/
|
|
static HRESULT WINAPI IDirectSoundNotify_QueryInterface(
|
|
LPDIRECTSOUNDNOTIFY this,REFIID riid,LPVOID *ppobj
|
|
) {
|
|
char xbuf[50];
|
|
|
|
WINE_StringFromCLSID(riid,xbuf);
|
|
TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
|
|
return E_FAIL;
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSoundNotify_AddRef(LPDIRECTSOUNDNOTIFY this) {
|
|
return ++(this->ref);
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSoundNotify_Release(LPDIRECTSOUNDNOTIFY this) {
|
|
this->ref--;
|
|
if (!this->ref) {
|
|
this->dsb->lpvtbl->fnRelease(this->dsb);
|
|
HeapFree(GetProcessHeap(),0,this);
|
|
return 0;
|
|
}
|
|
return this->ref;
|
|
}
|
|
|
|
static int _sort_notifies(const void *a,const void *b) {
|
|
LPDSBPOSITIONNOTIFY na = (LPDSBPOSITIONNOTIFY)a;
|
|
LPDSBPOSITIONNOTIFY nb = (LPDSBPOSITIONNOTIFY)b;
|
|
|
|
return na->dwOffset-nb->dwOffset;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundNotify_SetNotificationPositions(
|
|
LPDIRECTSOUNDNOTIFY this,DWORD howmuch,LPCDSBPOSITIONNOTIFY notify
|
|
) {
|
|
int i;
|
|
|
|
if (TRACE_ON(dsound)) {
|
|
TRACE(dsound,"(%p,0x%08lx,%p)\n",this,howmuch,notify);
|
|
for (i=0;i<howmuch;i++)
|
|
TRACE(dsound,"notify at %ld to 0x%08lx\n",
|
|
notify[i].dwOffset,(DWORD)notify[i].hEventNotify);
|
|
}
|
|
this->dsb->notifies = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,this->dsb->notifies,(this->dsb->nrofnotifies+howmuch)*sizeof(DSBPOSITIONNOTIFY));
|
|
memcpy( this->dsb->notifies+this->dsb->nrofnotifies,
|
|
notify,
|
|
howmuch*sizeof(DSBPOSITIONNOTIFY)
|
|
);
|
|
this->dsb->nrofnotifies+=howmuch;
|
|
qsort(this->dsb->notifies,this->dsb->nrofnotifies,sizeof(DSBPOSITIONNOTIFY),_sort_notifies);
|
|
return 0;
|
|
}
|
|
|
|
IDirectSoundNotify_VTable dsnvt = {
|
|
IDirectSoundNotify_QueryInterface,
|
|
IDirectSoundNotify_AddRef,
|
|
IDirectSoundNotify_Release,
|
|
IDirectSoundNotify_SetNotificationPositions,
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* IDirectSoundBuffer
|
|
*/
|
|
|
|
// This sets this format for the <em>Primary Buffer Only</em>
|
|
// See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 120
|
|
static HRESULT WINAPI IDirectSoundBuffer_SetFormat(
|
|
LPDIRECTSOUNDBUFFER this,LPWAVEFORMATEX wfex
|
|
) {
|
|
LPDIRECTSOUNDBUFFER *dsb;
|
|
int i;
|
|
|
|
if (primarybuf->wfx.nSamplesPerSec != wfex->nSamplesPerSec) {
|
|
dsb = dsound->buffers;
|
|
for (i = 0; i < dsound->nrofbuffers; i++, dsb++)
|
|
(*dsb)->freqAdjust = ((*dsb)->freq << 14) / wfex->nSamplesPerSec;
|
|
}
|
|
|
|
memcpy(&(primarybuf->wfx),wfex,sizeof(primarybuf->wfx));
|
|
TRACE(dsound,"(%p,%p)\n", this,wfex);
|
|
TRACE(dsound,"(formattag=0x%04x,chans=%d,samplerate=%ld"
|
|
"bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
|
|
wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
|
|
wfex->nAvgBytesPerSec, wfex->nBlockAlign,
|
|
wfex->wBitsPerSample, wfex->cbSize);
|
|
|
|
if (this->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
|
|
this->wfx.nAvgBytesPerSec =
|
|
this->wfx.nSamplesPerSec * this->wfx.nBlockAlign;
|
|
DSOUND_CloseAudio();
|
|
return DS_OK;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_SetVolume(
|
|
LPDIRECTSOUNDBUFFER this,LONG vol
|
|
) {
|
|
double temp;
|
|
|
|
TRACE(dsound,"(%p,%ld)\n",this,vol);
|
|
|
|
// I'm not sure if we need this for primary buffer
|
|
if (!(this->dsbd.dwFlags & DSBCAPS_CTRLVOLUME))
|
|
return DSERR_CONTROLUNAVAIL;
|
|
|
|
if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN))
|
|
return DSERR_INVALIDPARAM;
|
|
|
|
// This needs to adjust the soundcard volume when
|
|
// called for the primary buffer
|
|
if (this->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
|
|
FIXME(dsound, "Volume control of primary unimplemented.\n");
|
|
this->volume = vol;
|
|
return DS_OK;
|
|
}
|
|
|
|
this->volume = vol;
|
|
|
|
temp = (double) (this->volume + (this->pan < 0 ? this->pan : 0));
|
|
this->lVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 65536.0);
|
|
temp = (double) (this->volume - (this->pan > 0 ? this->pan : 0));
|
|
this->rVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 65536.0);
|
|
|
|
TRACE(dsound, "left = %lx, right = %lx\n", this->lVolAdjust, this->rVolAdjust);
|
|
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_GetVolume(
|
|
LPDIRECTSOUNDBUFFER this,LPLONG vol
|
|
) {
|
|
TRACE(dsound,"(%p,%p)\n",this,vol);
|
|
*vol = this->volume;
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_SetFrequency(
|
|
LPDIRECTSOUNDBUFFER this,DWORD freq
|
|
) {
|
|
TRACE(dsound,"(%p,%ld)\n",this,freq);
|
|
|
|
// You cannot set the frequency of the primary buffer
|
|
if (!(this->dsbd.dwFlags & DSBCAPS_CTRLFREQUENCY) ||
|
|
(this->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER))
|
|
return DSERR_CONTROLUNAVAIL;
|
|
|
|
if ((freq < DSBFREQUENCY_MIN) || (freq > DSBFREQUENCY_MAX))
|
|
return DSERR_INVALIDPARAM;
|
|
|
|
this->freq = freq;
|
|
this->freqAdjust = (freq << 14) / primarybuf->wfx.nSamplesPerSec;
|
|
this->nAvgBytesPerSec = freq * (this->wfx.wBitsPerSample >> 3) * this->wfx.nChannels;
|
|
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_Play(
|
|
LPDIRECTSOUNDBUFFER this,DWORD reserved1,DWORD reserved2,DWORD flags
|
|
) {
|
|
TRACE(dsound,"(%p,%08lx,%08lx,%08lx)\n",
|
|
this,reserved1,reserved2,flags
|
|
);
|
|
this->playflags = flags;
|
|
this->playing = 1;
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_Stop(LPDIRECTSOUNDBUFFER this) {
|
|
TRACE(dsound,"(%p)\n",this);
|
|
this->playing = 0;
|
|
return 0;
|
|
}
|
|
|
|
static DWORD WINAPI IDirectSoundBuffer_AddRef(LPDIRECTSOUNDBUFFER this) {
|
|
// TRACE(dsound,"(%p) ref was %ld\n",this, this->ref);
|
|
|
|
return ++(this->ref);
|
|
}
|
|
static DWORD WINAPI IDirectSoundBuffer_Release(LPDIRECTSOUNDBUFFER this) {
|
|
int i;
|
|
|
|
// TRACE(dsound,"(%p) ref was %ld\n",this, this->ref);
|
|
|
|
if (--this->ref)
|
|
return this->ref;
|
|
for (i=0;i<this->dsound->nrofbuffers;i++)
|
|
if (this->dsound->buffers[i] == this)
|
|
break;
|
|
if (i < this->dsound->nrofbuffers) {
|
|
/* Put the last buffer of the list in the (now empty) position */
|
|
this->dsound->buffers[i] = this->dsound->buffers[this->dsound->nrofbuffers - 1];
|
|
this->dsound->buffers = HeapReAlloc(GetProcessHeap(),0,this->dsound->buffers,sizeof(LPDIRECTSOUNDBUFFER)*this->dsound->nrofbuffers);
|
|
this->dsound->nrofbuffers--;
|
|
this->dsound->lpvtbl->fnRelease(this->dsound);
|
|
}
|
|
|
|
if (this->ds3db && this->ds3db->lpvtbl)
|
|
this->ds3db->lpvtbl->fnRelease(this->ds3db);
|
|
HeapFree(GetProcessHeap(),0,this->buffer);
|
|
HeapFree(GetProcessHeap(),0,this);
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_GetCurrentPosition(
|
|
LPDIRECTSOUNDBUFFER this,LPDWORD playpos,LPDWORD writepos
|
|
) {
|
|
TRACE(dsound,"(%p,%p,%p)\n",this,playpos,writepos);
|
|
if (playpos) *playpos = this->playpos;
|
|
if (writepos) *writepos = this->writepos;
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_GetStatus(
|
|
LPDIRECTSOUNDBUFFER this,LPDWORD status
|
|
) {
|
|
TRACE(dsound,"(%p,%p)\n",this,status);
|
|
*status = 0;
|
|
if (this->playing)
|
|
*status |= DSBSTATUS_PLAYING;
|
|
if (this->playflags & DSBPLAY_LOOPING)
|
|
*status |= DSBSTATUS_LOOPING;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_GetFormat(
|
|
LPDIRECTSOUNDBUFFER this,LPWAVEFORMATEX lpwf,DWORD wfsize,LPDWORD wfwritten
|
|
) {
|
|
TRACE(dsound,"(%p,%p,%ld,%p)\n",this,lpwf,wfsize,wfwritten);
|
|
if (wfsize>sizeof(this->wfx))
|
|
wfsize = sizeof(this->wfx);
|
|
if (lpwf) { // NULL is valid
|
|
memcpy(lpwf,&(this->wfx),wfsize);
|
|
if (wfwritten)
|
|
*wfwritten = wfsize;
|
|
} else
|
|
if (wfwritten)
|
|
*wfwritten = sizeof(this->wfx);
|
|
else
|
|
return DSERR_INVALIDPARAM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_Lock(
|
|
LPDIRECTSOUNDBUFFER this,DWORD writecursor,DWORD writebytes,LPVOID lplpaudioptr1,LPDWORD audiobytes1,LPVOID lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
|
|
) {
|
|
|
|
TRACE(dsound,"(%p,%ld,%ld,%p,%p,%p,%p,0x%08lx)\n",
|
|
this,
|
|
writecursor,
|
|
writebytes,
|
|
lplpaudioptr1,
|
|
audiobytes1,
|
|
lplpaudioptr2,
|
|
audiobytes2,
|
|
flags
|
|
);
|
|
if (flags & DSBLOCK_FROMWRITECURSOR)
|
|
writecursor = this->writepos;
|
|
if (flags & DSBLOCK_ENTIREBUFFER)
|
|
writebytes = this->buflen;
|
|
if (writebytes > this->buflen)
|
|
writebytes = this->buflen;
|
|
|
|
assert(audiobytes1!=audiobytes2);
|
|
assert(lplpaudioptr1!=lplpaudioptr2);
|
|
if (writecursor+writebytes <= this->buflen) {
|
|
*(LPBYTE*)lplpaudioptr1 = this->buffer+writecursor;
|
|
*audiobytes1 = writebytes;
|
|
if (lplpaudioptr2)
|
|
*(LPBYTE*)lplpaudioptr2 = NULL;
|
|
if (audiobytes2)
|
|
*audiobytes2 = 0;
|
|
TRACE(dsound,"->%ld.0\n",writebytes);
|
|
} else {
|
|
*(LPBYTE*)lplpaudioptr1 = this->buffer+writecursor;
|
|
*audiobytes1 = this->buflen-writecursor;
|
|
if (lplpaudioptr2)
|
|
*(LPBYTE*)lplpaudioptr2 = this->buffer;
|
|
if (audiobytes2)
|
|
*audiobytes2 = writebytes-(this->buflen-writecursor);
|
|
TRACE(dsound,"->%ld.%ld\n",*audiobytes1,audiobytes2?*audiobytes2:0);
|
|
}
|
|
// No. See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 21
|
|
// this->writepos=(writecursor+writebytes)%this->buflen;
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_SetCurrentPosition(
|
|
LPDIRECTSOUNDBUFFER this,DWORD newpos
|
|
) {
|
|
TRACE(dsound,"(%p,%ld)\n",this,newpos);
|
|
this->playpos = newpos;
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_SetPan(
|
|
LPDIRECTSOUNDBUFFER this,LONG pan
|
|
) {
|
|
double temp;
|
|
|
|
TRACE(dsound,"(%p,%ld)\n",this,pan);
|
|
|
|
// What do we do if some moron uses SetPan with
|
|
// a mono primary buffer?
|
|
|
|
// You cannot set the pan of the primary buffer
|
|
// and you cannot use both pan and 3D controls
|
|
if (!(this->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
|
|
(this->dsbd.dwFlags & DSBCAPS_CTRL3D) ||
|
|
(this->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER))
|
|
return DSERR_CONTROLUNAVAIL;
|
|
|
|
if ((pan > DSBPAN_RIGHT) || (pan < DSBPAN_LEFT))
|
|
return DSERR_INVALIDPARAM;
|
|
|
|
this->pan = pan;
|
|
|
|
temp = (double) (this->volume + (this->pan < 0 ? this->pan : 0));
|
|
this->lVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 65536.0);
|
|
temp = (double) (this->volume - (this->pan > 0 ? this->pan : 0));
|
|
this->rVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 65536.0);
|
|
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_GetPan(
|
|
LPDIRECTSOUNDBUFFER this,LPLONG pan
|
|
) {
|
|
TRACE(dsound,"(%p,%p)\n",this,pan);
|
|
*pan = this->pan;
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_Unlock(
|
|
LPDIRECTSOUNDBUFFER this,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
|
|
) {
|
|
TRACE(dsound,"(%p,%p,%ld,%p,%ld):stub\n", this,p1,x1,p2,x2);
|
|
this->writepos = this->playpos + (this->wfx.nAvgBytesPerSec >> 4);
|
|
this->writepos %= this->buflen;
|
|
|
|
#if 0
|
|
// This is highly experimental and liable to break things
|
|
if (this->dsbd.dwFlags & DSBCAPS_CTRL3D)
|
|
DSOUND_Create3DBuffer(this);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_GetFrequency(
|
|
LPDIRECTSOUNDBUFFER this,LPDWORD freq
|
|
) {
|
|
TRACE(dsound,"(%p,%p)\n",this,freq);
|
|
*freq = this->freq;
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_Initialize(
|
|
LPDIRECTSOUNDBUFFER this,LPDIRECTSOUND dsound,LPDSBUFFERDESC dbsd
|
|
) {
|
|
FIXME(dsound,"(%p,%p,%p):stub\n",this,dsound,dbsd);
|
|
printf("Re-Init!!!\n");
|
|
return DSERR_ALREADYINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_GetCaps(
|
|
LPDIRECTSOUNDBUFFER this,LPDSBCAPS caps
|
|
) {
|
|
TRACE(dsound,"(%p)->(%p)\n",this,caps);
|
|
|
|
caps->dwSize = sizeof(*caps);
|
|
caps->dwFlags = this->dsbd.dwFlags | DSBCAPS_LOCSOFTWARE;
|
|
caps->dwBufferBytes = this->dsbd.dwBufferBytes;
|
|
/* This value represents the speed of the "unlock" command.
|
|
As unlock is quite fast (it does not do anything), I put
|
|
4096 ko/s = 4 Mo / s */
|
|
caps->dwUnlockTransferRate = 4096;
|
|
caps->dwPlayCpuOverhead = 0;
|
|
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSoundBuffer_QueryInterface(
|
|
LPDIRECTSOUNDBUFFER this,REFIID riid,LPVOID *ppobj
|
|
) {
|
|
char xbuf[50];
|
|
|
|
WINE_StringFromCLSID(riid,xbuf);
|
|
TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
|
|
|
|
if (!memcmp(&IID_IDirectSoundNotify,riid,sizeof(*riid))) {
|
|
IDirectSoundNotify *dsn;
|
|
|
|
dsn = (LPDIRECTSOUNDNOTIFY)HeapAlloc(GetProcessHeap(),0,sizeof(*dsn));
|
|
dsn->ref = 1;
|
|
dsn->dsb = this;
|
|
this->lpvtbl->fnAddRef(this);
|
|
dsn->lpvtbl = &dsnvt;
|
|
*ppobj = (LPVOID)dsn;
|
|
return 0;
|
|
}
|
|
|
|
if (!memcmp(&IID_IDirectSound3DBuffer,riid,sizeof(*riid))) {
|
|
*ppobj = this->ds3db;
|
|
if (*ppobj)
|
|
return DS_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
static struct tagLPDIRECTSOUNDBUFFER_VTABLE dsbvt = {
|
|
IDirectSoundBuffer_QueryInterface,
|
|
IDirectSoundBuffer_AddRef,
|
|
IDirectSoundBuffer_Release,
|
|
IDirectSoundBuffer_GetCaps,
|
|
IDirectSoundBuffer_GetCurrentPosition,
|
|
IDirectSoundBuffer_GetFormat,
|
|
IDirectSoundBuffer_GetVolume,
|
|
IDirectSoundBuffer_GetPan,
|
|
IDirectSoundBuffer_GetFrequency,
|
|
IDirectSoundBuffer_GetStatus,
|
|
IDirectSoundBuffer_Initialize,
|
|
IDirectSoundBuffer_Lock,
|
|
IDirectSoundBuffer_Play,
|
|
IDirectSoundBuffer_SetCurrentPosition,
|
|
IDirectSoundBuffer_SetFormat,
|
|
IDirectSoundBuffer_SetVolume,
|
|
IDirectSoundBuffer_SetPan,
|
|
IDirectSoundBuffer_SetFrequency,
|
|
IDirectSoundBuffer_Stop,
|
|
IDirectSoundBuffer_Unlock
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* IDirectSound
|
|
*/
|
|
|
|
static HRESULT WINAPI IDirectSound_SetCooperativeLevel(
|
|
LPDIRECTSOUND this,HWND32 hwnd,DWORD level
|
|
) {
|
|
FIXME(dsound,"(%p,%08lx,%ld):stub\n",this,(DWORD)hwnd,level);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static HRESULT WINAPI IDirectSound_CreateSoundBuffer(
|
|
LPDIRECTSOUND this,LPDSBUFFERDESC dsbd,LPLPDIRECTSOUNDBUFFER ppdsb,LPUNKNOWN lpunk
|
|
) {
|
|
LPWAVEFORMATEX wfex = dsbd->lpwfxFormat;
|
|
|
|
if (TRACE_ON(dsound)) {
|
|
TRACE(dsound,"(%p,%p,%p,%p)\n",this,dsbd,ppdsb,lpunk);
|
|
TRACE(dsound,"(size=%ld)\n",dsbd->dwSize);
|
|
TRACE(dsound,"(flags=0x%08lx\n",dsbd->dwFlags);
|
|
_dump_DSBCAPS(dsbd->dwFlags);
|
|
TRACE(dsound,"(bufferbytes=%ld)\n",dsbd->dwBufferBytes);
|
|
TRACE(dsound,"(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
|
|
}
|
|
|
|
if (wfex)
|
|
TRACE(dsound,"(formattag=0x%04x,chans=%d,samplerate=%ld"
|
|
"bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
|
|
wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
|
|
wfex->nAvgBytesPerSec, wfex->nBlockAlign,
|
|
wfex->wBitsPerSample, wfex->cbSize);
|
|
|
|
if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
|
|
if (primarybuf) {
|
|
*ppdsb = primarybuf;
|
|
return DS_OK;
|
|
} // Else create primarybuf
|
|
}
|
|
|
|
*ppdsb = (LPDIRECTSOUNDBUFFER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBuffer));
|
|
if (*ppdsb == NULL)
|
|
return DSERR_OUTOFMEMORY;
|
|
(*ppdsb)->ref =1;
|
|
|
|
TRACE(dsound, "Created buffer at %p\n", *ppdsb);
|
|
|
|
if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)
|
|
(*ppdsb)->buflen = dsound->wfx.nAvgBytesPerSec;
|
|
else
|
|
(*ppdsb)->buflen = dsbd->dwBufferBytes;
|
|
(*ppdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,(*ppdsb)->buflen);
|
|
if ((*ppdsb)->buffer == NULL) {
|
|
HeapFree(GetProcessHeap(),0,(*ppdsb));
|
|
*ppdsb = NULL;
|
|
return DSERR_OUTOFMEMORY;
|
|
}
|
|
(*ppdsb)->playpos = 0;
|
|
(*ppdsb)->writepos = 0;
|
|
(*ppdsb)->lpvtbl = &dsbvt;
|
|
(*ppdsb)->dsound = this;
|
|
(*ppdsb)->playing = 0;
|
|
(*ppdsb)->lVolAdjust = (1 << 16);
|
|
(*ppdsb)->rVolAdjust = (1 << 16);
|
|
(*ppdsb)->freq = dsbd->lpwfxFormat->nSamplesPerSec;
|
|
|
|
if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
|
|
(*ppdsb)->freqAdjust = ((*ppdsb)->freq << 14) /
|
|
primarybuf->wfx.nSamplesPerSec;
|
|
(*ppdsb)->nAvgBytesPerSec = (*ppdsb)->freq *
|
|
(dsbd->lpwfxFormat->wBitsPerSample >> 3) *
|
|
dsbd->lpwfxFormat->nChannels;
|
|
}
|
|
|
|
memcpy(&((*ppdsb)->dsbd),dsbd,sizeof(*dsbd));
|
|
|
|
/* register buffer */
|
|
if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
|
|
this->buffers = (LPDIRECTSOUNDBUFFER*)HeapReAlloc(GetProcessHeap(),0,this->buffers,sizeof(LPDIRECTSOUNDBUFFER)*(this->nrofbuffers+1));
|
|
this->buffers[this->nrofbuffers] = *ppdsb;
|
|
this->nrofbuffers++;
|
|
this->lpvtbl->fnAddRef(this);
|
|
}
|
|
|
|
if (dsbd->lpwfxFormat && !(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER))
|
|
memcpy(&((*ppdsb)->wfx), dsbd->lpwfxFormat,
|
|
sizeof((*ppdsb)->wfx));
|
|
|
|
#if 0
|
|
if (dsbd->dwFlags & DSBCAPS_CTRL3D) {
|
|
IDirectSound3DBuffer *ds3db;
|
|
|
|
ds3db = (LPDIRECTSOUND3DBUFFER)HeapAlloc(GetProcessHeap(),
|
|
0,sizeof(*ds3db));
|
|
ds3db->ref = 1;
|
|
ds3db->dsb = (*ppdsb);
|
|
ds3db->lpvtbl = &ds3dbvt;
|
|
(*ppdsb)->ds3db = ds3db;
|
|
ds3db->ds3db.dwSize = sizeof(DS3DBUFFER);
|
|
ds3db->ds3db.vPosition.x = 0.0;
|
|
ds3db->ds3db.vPosition.y = 0.0;
|
|
ds3db->ds3db.vPosition.z = 0.0;
|
|
ds3db->ds3db.vVelocity.x = 0.0;
|
|
ds3db->ds3db.vVelocity.y = 0.0;
|
|
ds3db->ds3db.vVelocity.z = 0.0;
|
|
ds3db->ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
|
|
ds3db->ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
|
|
ds3db->ds3db.vConeOrientation.x = 0.0;
|
|
ds3db->ds3db.vConeOrientation.y = 0.0;
|
|
ds3db->ds3db.vConeOrientation.z = 0.0;
|
|
ds3db->ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
|
|
ds3db->ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
|
|
ds3db->ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
|
|
ds3db->ds3db.dwMode = DS3DMODE_NORMAL;
|
|
ds3db->buflen = ((*ppdsb)->buflen * primarybuf->wfx.nBlockAlign) /
|
|
(*ppdsb)->wfx.nBlockAlign;
|
|
ds3db->buffer = HeapAlloc(GetProcessHeap(), 0, ds3db->buflen);
|
|
if (ds3db->buffer == NULL) {
|
|
ds3db->buflen = 0;
|
|
ds3db->ds3db.dwMode = DS3DMODE_DISABLE;
|
|
}
|
|
}
|
|
#endif
|
|
return DS_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound_DuplicateSoundBuffer(
|
|
LPDIRECTSOUND this,LPDIRECTSOUNDBUFFER pdsb,LPLPDIRECTSOUNDBUFFER ppdsb
|
|
) {
|
|
TRACE(dsound,"(%p,%p,%p)\n",this,pdsb,ppdsb);
|
|
|
|
*ppdsb = (LPDIRECTSOUNDBUFFER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBuffer));
|
|
|
|
(*ppdsb)->ref =1;
|
|
(*ppdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,pdsb->buflen);
|
|
memcpy((*ppdsb)->buffer,pdsb->buffer,pdsb->buflen);
|
|
(*ppdsb)->buflen = pdsb->buflen;
|
|
(*ppdsb)->playpos = 0;
|
|
(*ppdsb)->writepos = 0;
|
|
(*ppdsb)->lpvtbl = &dsbvt;
|
|
(*ppdsb)->dsound = this;
|
|
memcpy(&((*ppdsb)->wfx), &(pdsb->wfx), sizeof((*ppdsb)->wfx));
|
|
/* register buffer */
|
|
this->buffers = (LPDIRECTSOUNDBUFFER*)HeapReAlloc(GetProcessHeap(),0,this->buffers,sizeof(LPDIRECTSOUNDBUFFER)*(this->nrofbuffers+1));
|
|
this->buffers[this->nrofbuffers] = *ppdsb;
|
|
this->nrofbuffers++;
|
|
this->lpvtbl->fnAddRef(this);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static HRESULT WINAPI IDirectSound_GetCaps(LPDIRECTSOUND this,LPDSCAPS caps) {
|
|
TRACE(dsound,"(%p,%p)\n",this,caps);
|
|
TRACE(dsound,"(flags=0x%08lx)\n",caps->dwFlags);
|
|
|
|
caps->dwSize = sizeof(*caps);
|
|
caps->dwFlags =
|
|
DSCAPS_PRIMARYSTEREO |
|
|
DSCAPS_PRIMARY16BIT |
|
|
DSCAPS_SECONDARYSTEREO |
|
|
DSCAPS_SECONDARY16BIT |
|
|
DSCAPS_CONTINUOUSRATE;
|
|
/* FIXME: query OSS */
|
|
caps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
|
|
caps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
|
|
|
|
caps->dwPrimaryBuffers = 1;
|
|
|
|
caps->dwMaxHwMixingAllBuffers = 0;
|
|
caps->dwMaxHwMixingStaticBuffers = 0;
|
|
caps->dwMaxHwMixingStreamingBuffers = 0;
|
|
|
|
caps->dwFreeHwMixingAllBuffers = 0;
|
|
caps->dwFreeHwMixingStaticBuffers = 0;
|
|
caps->dwFreeHwMixingStreamingBuffers = 0;
|
|
|
|
caps->dwMaxHw3DAllBuffers = 0;
|
|
caps->dwMaxHw3DStaticBuffers = 0;
|
|
caps->dwMaxHw3DStreamingBuffers = 0;
|
|
|
|
caps->dwFreeHw3DAllBuffers = 0;
|
|
caps->dwFreeHw3DStaticBuffers = 0;
|
|
caps->dwFreeHw3DStreamingBuffers = 0;
|
|
|
|
caps->dwTotalHwMemBytes = 0;
|
|
|
|
caps->dwFreeHwMemBytes = 0;
|
|
|
|
caps->dwMaxContigFreeHwMemBytes = 0;
|
|
|
|
caps->dwUnlockTransferRateHwBuffers = 4096; // But we have none...
|
|
|
|
caps->dwPlayCpuOverheadSwBuffers = 1; // 1%
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSound_AddRef(LPDIRECTSOUND this) {
|
|
return ++(this->ref);
|
|
}
|
|
|
|
static ULONG WINAPI IDirectSound_Release(LPDIRECTSOUND this) {
|
|
TRACE(dsound,"(%p), ref was %ld\n",this,this->ref);
|
|
if (!--(this->ref)) {
|
|
HeapFree(GetProcessHeap(),0,this);
|
|
dsound = NULL;
|
|
DSOUND_CloseAudio();
|
|
return 0;
|
|
}
|
|
return this->ref;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound_SetSpeakerConfig(
|
|
LPDIRECTSOUND this,DWORD config
|
|
) {
|
|
FIXME(dsound,"(%p,0x%08lx):stub\n",this,config);
|
|
return 0;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound_QueryInterface(
|
|
LPDIRECTSOUND this,REFIID riid,LPVOID *ppobj
|
|
) {
|
|
char xbuf[50];
|
|
|
|
if (!memcmp(&IID_IDirectSound3DListener,riid,sizeof(*riid))) {
|
|
|
|
if (this->listener) {
|
|
*ppobj = this->listener;
|
|
return DS_OK;
|
|
}
|
|
this->listener = (LPDIRECTSOUND3DLISTENER)HeapAlloc(
|
|
GetProcessHeap(), 0, sizeof(*(this->listener)));
|
|
this->listener->ref = 1;
|
|
this->listener->lpvtbl = &ds3dlvt;
|
|
this->lpvtbl->fnAddRef(this);
|
|
this->listener->ds3dl.dwSize = sizeof(DS3DLISTENER);
|
|
this->listener->ds3dl.vPosition.x = 0.0;
|
|
this->listener->ds3dl.vPosition.y = 0.0;
|
|
this->listener->ds3dl.vPosition.z = 0.0;
|
|
this->listener->ds3dl.vVelocity.x = 0.0;
|
|
this->listener->ds3dl.vVelocity.y = 0.0;
|
|
this->listener->ds3dl.vVelocity.z = 0.0;
|
|
this->listener->ds3dl.vOrientFront.x = 0.0;
|
|
this->listener->ds3dl.vOrientFront.y = 0.0;
|
|
this->listener->ds3dl.vOrientFront.z = 1.0;
|
|
this->listener->ds3dl.vOrientTop.x = 0.0;
|
|
this->listener->ds3dl.vOrientTop.y = 1.0;
|
|
this->listener->ds3dl.vOrientTop.z = 0.0;
|
|
this->listener->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
|
|
this->listener->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
|
|
this->listener->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
|
|
*ppobj = (LPVOID)this->listener;
|
|
return DS_OK;
|
|
}
|
|
|
|
WINE_StringFromCLSID(riid,xbuf);
|
|
TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
|
|
return E_FAIL;
|
|
}
|
|
|
|
static HRESULT WINAPI IDirectSound_Initialize(LPDIRECTSOUND this,GUID*lpguid) {
|
|
FIXME(dsound,"(%p)->(%p),stub!\n",this,lpguid);
|
|
return 0;
|
|
}
|
|
|
|
static struct tagLPDIRECTSOUND_VTABLE dsvt = {
|
|
IDirectSound_QueryInterface,
|
|
IDirectSound_AddRef,
|
|
IDirectSound_Release,
|
|
IDirectSound_CreateSoundBuffer,
|
|
IDirectSound_GetCaps,
|
|
IDirectSound_DuplicateSoundBuffer,
|
|
IDirectSound_SetCooperativeLevel,
|
|
(void *)8,
|
|
(void *)9,
|
|
IDirectSound_SetSpeakerConfig,
|
|
IDirectSound_Initialize
|
|
};
|
|
|
|
static int
|
|
DSOUND_setformat(LPWAVEFORMATEX wfex) {
|
|
int xx,channels,speed,format,nformat;
|
|
|
|
// Race condition here... called by DSOUND_thread() and SetFormat()
|
|
if (!audioOK) {
|
|
TRACE(dsound, "(%p) deferred\n", wfex);
|
|
return 0;
|
|
}
|
|
switch (wfex->wFormatTag) {
|
|
default:
|
|
WARN(dsound,"unknown WAVE_FORMAT tag %d\n",wfex->wFormatTag);
|
|
return DSERR_BADFORMAT;
|
|
case WAVE_FORMAT_PCM:
|
|
break;
|
|
}
|
|
if (wfex->wBitsPerSample==8)
|
|
format = AFMT_U8;
|
|
else
|
|
format = AFMT_S16_LE;
|
|
|
|
if (-1==ioctl(audiofd,SNDCTL_DSP_GETFMTS,&xx)) {
|
|
perror("ioctl SNDCTL_DSP_GETFMTS");
|
|
return -1;
|
|
}
|
|
if ((xx&format)!=format) {/* format unsupported */
|
|
FIXME(dsound,"SNDCTL_DSP_GETFMTS: format not supported\n");
|
|
return -1;
|
|
}
|
|
nformat = format;
|
|
if (-1==ioctl(audiofd,SNDCTL_DSP_SETFMT,&nformat)) {
|
|
perror("ioctl SNDCTL_DSP_SETFMT");
|
|
return -1;
|
|
}
|
|
if (nformat!=format) {/* didn't work */
|
|
FIXME(dsound,"SNDCTL_DSP_GETFMTS: format not set\n");
|
|
return -1;
|
|
}
|
|
|
|
channels = wfex->nChannels-1;
|
|
if (-1==ioctl(audiofd,SNDCTL_DSP_STEREO,&channels)) {
|
|
perror("ioctl SNDCTL_DSP_STEREO");
|
|
return -1;
|
|
}
|
|
speed = wfex->nSamplesPerSec;
|
|
if (-1==ioctl(audiofd,SNDCTL_DSP_SPEED,&speed)) {
|
|
perror("ioctl SNDCTL_DSP_SPEED");
|
|
return -1;
|
|
}
|
|
TRACE(dsound,"(freq=%ld,channels=%d,bits=%d)\n",
|
|
wfex->nSamplesPerSec,wfex->nChannels,wfex->wBitsPerSample
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
static void DSOUND_CheckEvent(IDirectSoundBuffer *dsb, int len)
|
|
{
|
|
int i;
|
|
DWORD offset;
|
|
LPDSBPOSITIONNOTIFY event;
|
|
|
|
if (dsb->nrofnotifies == 0)
|
|
return;
|
|
|
|
TRACE(dsound,"(%p)\n", dsb);
|
|
for (i = 0; i < dsb->nrofnotifies; i++) {
|
|
event = dsb->notifies + i;
|
|
offset = event->dwOffset;
|
|
if ((dsb->playpos + len) >= dsb->buflen)
|
|
if ((offset <= (dsb->playpos + len - dsb->buflen)) ||
|
|
(offset > dsb->playpos)) {
|
|
SetEvent(event->hEventNotify);
|
|
TRACE(dsound,"signalled event %d\n", event->hEventNotify);
|
|
}
|
|
else
|
|
if ((offset > dsb->playpos) || (offset <= (dsb->playpos + len))) {
|
|
SetEvent(event->hEventNotify);
|
|
TRACE(dsound,"signalled event %d\n", event->hEventNotify);
|
|
}
|
|
}
|
|
}
|
|
|
|
// This should be the correct way to do this.
|
|
// Anyone want to do the optimized assembly?
|
|
static inline short cvt8to16(char byte)
|
|
{
|
|
short s = 0, sbit = 1;
|
|
char cbit = 1;
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if (byte & cbit)
|
|
s |= sbit;
|
|
cbit <<= 1;
|
|
sbit <<= 2;
|
|
}
|
|
if (byte < 0)
|
|
s |= 0x8000; // sign bit
|
|
return s;
|
|
}
|
|
|
|
static inline char cvt16to8(short word)
|
|
{
|
|
char c = 0, cbit = 1;
|
|
short sbits = 3;
|
|
int i;
|
|
|
|
for (i = 0; i < 7; i++) {
|
|
if (word & sbits)
|
|
c |= cbit;
|
|
cbit <<= 1;
|
|
sbits <<= 2;
|
|
}
|
|
if (word < 0)
|
|
c |= 0x80; // sign bit
|
|
return c;
|
|
}
|
|
|
|
static inline void get_fields(const IDirectSoundBuffer *dsb, char *buf, int *fl, int *fr)
|
|
{
|
|
short *bufs = (short *) buf;
|
|
|
|
// TRACE(dsound, "(%p)", buf);
|
|
if ((dsb->wfx.wBitsPerSample == 8) && dsb->wfx.nChannels == 2) {
|
|
*fl = cvt8to16(*buf);
|
|
*fr = cvt8to16(*(buf + 1));
|
|
return;
|
|
}
|
|
|
|
if ((dsb->wfx.wBitsPerSample == 16) && dsb->wfx.nChannels == 2) {
|
|
*fl = *bufs;
|
|
*fr = *(bufs + 1);
|
|
return;
|
|
}
|
|
|
|
if ((dsb->wfx.wBitsPerSample == 8) && dsb->wfx.nChannels == 1) {
|
|
*fr = *fl = cvt8to16(*buf);
|
|
return;
|
|
}
|
|
|
|
if ((dsb->wfx.wBitsPerSample == 16) && dsb->wfx.nChannels == 1) {
|
|
*fr = *fl = *bufs;
|
|
return;
|
|
}
|
|
|
|
FIXME(dsound, "get_fields found an unsupported configuration\n");
|
|
return;
|
|
}
|
|
|
|
static inline void set_fields(char *buf, int fl, int fr)
|
|
{
|
|
short *bufs = (short *) buf;
|
|
|
|
if ((primarybuf->wfx.wBitsPerSample == 8) && (primarybuf->wfx.nChannels == 2)) {
|
|
*buf = cvt16to8(fl);
|
|
*(buf + 1) = cvt16to8(fr);
|
|
return;
|
|
}
|
|
|
|
if ((primarybuf->wfx.wBitsPerSample == 16) && (primarybuf->wfx.nChannels == 2)) {
|
|
*bufs = fl;
|
|
*(bufs + 1) = fr;
|
|
return;
|
|
}
|
|
|
|
if ((primarybuf->wfx.wBitsPerSample == 8) && (primarybuf->wfx.nChannels == 1)) {
|
|
*buf = cvt16to8((fl + fr) / 2);
|
|
return;
|
|
}
|
|
|
|
if ((primarybuf->wfx.wBitsPerSample == 16) && (primarybuf->wfx.nChannels == 1)) {
|
|
*bufs = (fl + fr) / 2;
|
|
return;
|
|
}
|
|
FIXME(dsound, "set_fields found an unsupported configuration\n");
|
|
return;
|
|
}
|
|
|
|
// Now with PerfectPitch (tm) technology
|
|
static void DSOUND_MixerNorm(IDirectSoundBuffer *dsb, char *buf, int len)
|
|
{
|
|
int i, ipos, fieldL, fieldR;
|
|
char *ibp, *obp;
|
|
int iAdvance = dsb->wfx.nBlockAlign;
|
|
int oAdvance = primarybuf->wfx.nBlockAlign;
|
|
|
|
ibp = dsb->buffer + dsb->playpos;
|
|
obp = buf;
|
|
|
|
TRACE(dsound, "(%p, %p, %p), playpos=%8.8lx\n", dsb, ibp, obp, dsb->playpos);
|
|
// Check for the best case
|
|
if ((dsb->freq == primarybuf->wfx.nSamplesPerSec) &&
|
|
(dsb->wfx.wBitsPerSample == primarybuf->wfx.wBitsPerSample) &&
|
|
(dsb->wfx.nChannels == primarybuf->wfx.nChannels)) {
|
|
TRACE(dsound, "(%p) Best case\n", dsb);
|
|
if ((ibp + len) <= (char *)(dsb->buffer + dsb->buflen))
|
|
memcpy(obp, ibp, len);
|
|
else { // wrap
|
|
memcpy(obp, ibp, dsb->buflen - dsb->playpos);
|
|
memcpy(obp + (dsb->buflen - dsb->playpos),
|
|
dsb->buffer,
|
|
len - (dsb->buflen - dsb->playpos));
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Check for same sample rate
|
|
if (dsb->freq == primarybuf->wfx.nSamplesPerSec) {
|
|
TRACE(dsound, "(%p) Same sample rate %ld = primary %ld\n", dsb,
|
|
dsb->freq, primarybuf->wfx.nSamplesPerSec);
|
|
for (i = 0; i < len; i += oAdvance) {
|
|
get_fields(dsb, ibp, &fieldL, &fieldR);
|
|
ibp += iAdvance;
|
|
set_fields(obp, fieldL, fieldR);
|
|
obp += oAdvance;
|
|
if (ibp > (char *)(dsb->buffer + dsb->buflen))
|
|
ibp = dsb->buffer; // wrap
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Mix in different sample rates
|
|
//
|
|
// New PerfectPitch(tm) Technology (c) 1998 Rob Riggs
|
|
// Patent Pending :-]
|
|
for (i = 0; i < len; i += oAdvance) {
|
|
|
|
ipos = (iAdvance * ((i * dsb->freqAdjust) >> 14)) + dsb->playpos;
|
|
|
|
if (ipos >= dsb->buflen)
|
|
ipos %= dsb->buflen; // wrap
|
|
|
|
get_fields(dsb, (dsb->buffer + ipos), &fieldL, &fieldR);
|
|
set_fields(obp, fieldL, fieldR);
|
|
obp += oAdvance;
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void DSOUND_MixerVol(IDirectSoundBuffer *dsb, char *buf, int len)
|
|
{
|
|
int i;
|
|
char *bpc;
|
|
short *bps;
|
|
|
|
TRACE(dsound, "(%p) left = %lx, right = %lx\n", dsb,
|
|
dsb->lVolAdjust, dsb->rVolAdjust);
|
|
if ((!(dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) || (dsb->pan == 0)) &&
|
|
(!(dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME) || (dsb->volume == 0)) &&
|
|
!(dsb->dsbd.dwFlags & DSBCAPS_CTRL3D))
|
|
return; // Nothing to do
|
|
|
|
// If we end up with some bozo coder using panning or 3D sound
|
|
// with a mono primary buffer, it could sound very weird using
|
|
// this method. Oh well, tough patooties.
|
|
|
|
for (i = 0; i < len; i += (primarybuf->wfx.wBitsPerSample >> 3)) {
|
|
register int val;
|
|
|
|
switch (primarybuf->wfx.wBitsPerSample) {
|
|
|
|
case 8:
|
|
bpc = buf + i;
|
|
val = *bpc;
|
|
val = (val * (i & 1 ? dsb->rVolAdjust : dsb->lVolAdjust)) >> 16;
|
|
*bpc = (char) val;
|
|
break;
|
|
case 16:
|
|
bps = (short *) (buf + i);
|
|
val = *bps;
|
|
val = (val * (i & 1 ? dsb->rVolAdjust : dsb->lVolAdjust)) >> 16;
|
|
*bps = (short) val;
|
|
break;
|
|
default:
|
|
// Very ugly!
|
|
FIXME(dsound, "MixerVol had a nasty error\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef USE_DSOUND3D
|
|
static void DSOUND_Mixer3D(IDirectSoundBuffer *dsb, char *buf, int len)
|
|
{
|
|
char *ibp, *obp;
|
|
DWORD buflen, playpos;
|
|
|
|
buflen = dsb->ds3db->buflen;
|
|
playpos = (dsb->playpos * primarybuf->wfx.nBlockAlign) / dsb->wfx.nBlockAlign;
|
|
ibp = dsb->ds3db->buffer + playpos;
|
|
obp = buf;
|
|
|
|
if (playpos > buflen) {
|
|
FIXME(dsound, "Major breakage");
|
|
return;
|
|
}
|
|
|
|
if (len <= (playpos + buflen))
|
|
memcpy(obp, ibp, len);
|
|
else { // wrap
|
|
memcpy(obp, ibp, buflen - playpos);
|
|
memcpy(obp + (buflen - playpos),
|
|
dsb->buffer,
|
|
len - (buflen - playpos));
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
static DWORD DSOUND_MixInBuffer(IDirectSoundBuffer *dsb)
|
|
{
|
|
int i, len, ilen, temp, field;
|
|
int advance = primarybuf->wfx.wBitsPerSample >> 3;
|
|
char *buf, *ibuf, *obuf;
|
|
short *ibufs, *obufs;
|
|
|
|
// The most we will use
|
|
len = primarybuf->wfx.nAvgBytesPerSec >> 4; // 60 ms
|
|
len &= ~3; // 4 byte alignment
|
|
if (!(dsb->playflags & DSBPLAY_LOOPING)) {
|
|
temp = ((primarybuf->wfx.nAvgBytesPerSec * dsb->buflen) /
|
|
dsb->wfx.nAvgBytesPerSec) -
|
|
((primarybuf->wfx.nAvgBytesPerSec * dsb->playpos) /
|
|
dsb->nAvgBytesPerSec);
|
|
len = (len > temp) ? temp : len;
|
|
}
|
|
|
|
ilen = (len * dsb->nAvgBytesPerSec) / primarybuf->wfx.nAvgBytesPerSec;
|
|
|
|
if ((buf = ibuf = (char *) malloc(len)) == NULL)
|
|
return 0;
|
|
|
|
TRACE(dsound, "MixInBuffer (%p) len = %d\n", dsb, len);
|
|
|
|
DSOUND_MixerNorm(dsb, ibuf, len);
|
|
if ((dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
|
|
(dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME))
|
|
DSOUND_MixerVol(dsb, ibuf, len);
|
|
|
|
TRACE(dsound, "Mixing buffer - advance = %d\n", advance);
|
|
obuf = primarybuf->buffer + primarybuf->playpos;
|
|
for (i = 0; i < len; i += advance) {
|
|
obufs = (short *) obuf;
|
|
ibufs = (short *) ibuf;
|
|
if (primarybuf->wfx.wBitsPerSample == 8) {
|
|
field = (char) *ibuf;
|
|
field += (char) *obuf;
|
|
field = field > 127 ? 127 : field;
|
|
field = field < -128 ? -128 : field;
|
|
*obuf = (char) field;
|
|
} else {
|
|
field = *ibufs;
|
|
field += *obufs;
|
|
field = field > 32767 ? 32767 : field;
|
|
field = field < -32768 ? -32768 : field;
|
|
*obufs = field;
|
|
}
|
|
ibuf += advance;
|
|
obuf += advance;
|
|
if (obuf > (char *)(primarybuf->buffer + primarybuf->buflen))
|
|
obuf = primarybuf->buffer;
|
|
}
|
|
free(buf);
|
|
|
|
if (dsb->dsbd.dwFlags & DSBCAPS_CTRLPOSITIONNOTIFY)
|
|
DSOUND_CheckEvent(dsb, len);
|
|
|
|
dsb->playpos += ilen;
|
|
dsb->writepos += ilen;
|
|
|
|
if (dsb->playpos >= dsb->buflen) {
|
|
if (!(dsb->playflags & DSBPLAY_LOOPING)) {
|
|
dsb->playing = 0;
|
|
dsb->writepos = 0;
|
|
dsb->playpos = 0;
|
|
} else
|
|
dsb->playpos -= dsb->buflen; // wrap
|
|
}
|
|
|
|
if (dsb->writepos > dsb->buflen)
|
|
dsb->writepos -= dsb->buflen;
|
|
|
|
return len;
|
|
}
|
|
|
|
static DWORD WINAPI DSOUND_MixPrimary(void)
|
|
{
|
|
int i, len, maxlen = 0;
|
|
IDirectSoundBuffer *dsb;
|
|
|
|
for (i = dsound->nrofbuffers - 1; i >= 0; i--) {
|
|
dsb = dsound->buffers[i];
|
|
|
|
if (!dsb || !(dsb->lpvtbl))
|
|
continue;
|
|
dsb->lpvtbl->fnAddRef(dsb);
|
|
if (dsb->buflen && dsb->playing) {
|
|
len = DSOUND_MixInBuffer(dsb);
|
|
maxlen = len > maxlen ? len : maxlen;
|
|
}
|
|
dsb->lpvtbl->fnRelease(dsb);
|
|
}
|
|
|
|
if (maxlen > 0) {
|
|
primarybuf->writepos += maxlen;
|
|
if (primarybuf->writepos > primarybuf->buflen)
|
|
primarybuf->writepos -= primarybuf->buflen;
|
|
}
|
|
|
|
return maxlen;
|
|
}
|
|
|
|
static int DSOUND_OpenAudio(void)
|
|
{
|
|
int audioFragment;
|
|
|
|
if (primarybuf == NULL)
|
|
return DSERR_OUTOFMEMORY;
|
|
|
|
while (audiofd != -1)
|
|
sleep(5);
|
|
audiofd = open("/dev/audio",O_WRONLY);
|
|
if (audiofd==-1) {
|
|
perror("open /dev/audio");
|
|
audiofd = -1;
|
|
return DSERR_NODRIVER;
|
|
}
|
|
|
|
audioFragment=0x0002000c;
|
|
if (-1==ioctl(audiofd,SNDCTL_DSP_SETFRAGMENT,&audioFragment))
|
|
perror("ioctl SETFRAGMENT");
|
|
|
|
audioOK = 1;
|
|
DSOUND_setformat(&(primarybuf->wfx));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void DSOUND_CloseAudio(void)
|
|
{
|
|
audioOK = 0; // race condition
|
|
Sleep(5);
|
|
close(audiofd);
|
|
primarybuf->playpos = 0;
|
|
primarybuf->writepos = primarybuf->wfx.nAvgBytesPerSec >> 4;
|
|
memset(primarybuf->buffer, 0, primarybuf->buflen);
|
|
audiofd = -1;
|
|
TRACE(dsound, "Audio stopped\n");
|
|
}
|
|
|
|
static int DSOUND_WriteAudio(char *buf, int len)
|
|
{
|
|
int result, left = 0;
|
|
|
|
while (left < len) {
|
|
result = write(audiofd, buf + left, len - left);
|
|
if (result == -1)
|
|
if (errno == EINTR)
|
|
continue;
|
|
else
|
|
return result;
|
|
left += result;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static DWORD WINAPI DSOUND_thread(LPVOID arg)
|
|
{
|
|
int maxlen = primarybuf->wfx.nAvgBytesPerSec >> 4;
|
|
int len;
|
|
|
|
TRACE(dsound,"dsound is at pid %d\n",getpid());
|
|
while (1) {
|
|
if (!dsound) {
|
|
WARN(dsound,"DSOUND thread giving up.\n");
|
|
ExitThread(0);
|
|
}
|
|
if (getppid()==1) {
|
|
WARN(dsound,"DSOUND father died? Giving up.\n");
|
|
ExitThread(0);
|
|
}
|
|
/* RACE: dsound could be deleted */
|
|
dsound->lpvtbl->fnAddRef(dsound);
|
|
if (primarybuf == NULL) { // Should never happen
|
|
/* no soundbuffer yet... wait. */
|
|
Sleep(100);
|
|
dsound->lpvtbl->fnRelease(dsound);
|
|
continue;
|
|
}
|
|
len = DSOUND_MixPrimary();
|
|
if (primarybuf->playing)
|
|
len = maxlen > len ? maxlen : len;
|
|
if (len) {
|
|
if (audioOK == 0)
|
|
DSOUND_OpenAudio();
|
|
if (primarybuf->playpos + len > primarybuf->buflen) {
|
|
if (DSOUND_WriteAudio(
|
|
primarybuf->buffer + primarybuf->playpos,
|
|
primarybuf->buflen - primarybuf->playpos)
|
|
!= 0) {
|
|
perror("DSOUND_WriteAudio");
|
|
ExitThread(0);
|
|
}
|
|
memset(primarybuf->buffer + primarybuf->playpos, 0,
|
|
primarybuf->buflen - primarybuf->playpos);
|
|
if (DSOUND_WriteAudio(primarybuf->buffer,
|
|
len - (primarybuf->buflen - primarybuf->playpos)) != 0) {
|
|
perror("DSOUND_WriteAudio");
|
|
ExitThread(0);
|
|
}
|
|
memset(primarybuf->buffer, 0,
|
|
len - (primarybuf->buflen - primarybuf->playpos));
|
|
} else {
|
|
if (DSOUND_WriteAudio(
|
|
primarybuf->buffer + primarybuf->playpos,
|
|
len) != 0) {
|
|
perror("DSOUND_WriteAudio");
|
|
ExitThread(0);
|
|
}
|
|
memset(primarybuf->buffer + primarybuf->playpos, 0, len);
|
|
}
|
|
primarybuf->playpos += len;
|
|
if (primarybuf->playpos >= primarybuf->buflen)
|
|
primarybuf->playpos -= primarybuf->buflen;
|
|
primarybuf->writepos = primarybuf->playpos + maxlen;
|
|
if (primarybuf->writepos >= primarybuf->buflen)
|
|
primarybuf->writepos -= primarybuf->buflen;
|
|
} else {
|
|
/* no soundbuffer. close and wait. */
|
|
if (audioOK)
|
|
DSOUND_CloseAudio();
|
|
Sleep(100);
|
|
}
|
|
dsound->lpvtbl->fnRelease(dsound);
|
|
}
|
|
ExitThread(0);
|
|
}
|
|
|
|
#endif /* HAVE_OSS */
|
|
|
|
HRESULT WINAPI DirectSoundCreate(LPGUID lpGUID,LPDIRECTSOUND *ppDS,IUnknown *pUnkOuter )
|
|
{
|
|
if (lpGUID)
|
|
TRACE(dsound,"(%p,%p,%p)\n",lpGUID,ppDS,pUnkOuter);
|
|
else
|
|
TRACE(dsound,"DirectSoundCreate\n");
|
|
#ifdef HAVE_OSS
|
|
if (primarybuf)
|
|
return DSERR_ALLOCATED;
|
|
|
|
*ppDS = (LPDIRECTSOUND)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSound));
|
|
(*ppDS)->ref = 1;
|
|
(*ppDS)->lpvtbl = &dsvt;
|
|
(*ppDS)->buffers = NULL;
|
|
(*ppDS)->nrofbuffers = 0;
|
|
|
|
(*ppDS)->wfx.wFormatTag = 1;
|
|
(*ppDS)->wfx.nChannels = 2;
|
|
(*ppDS)->wfx.nSamplesPerSec = 22050;
|
|
(*ppDS)->wfx.nAvgBytesPerSec = 44100;
|
|
(*ppDS)->wfx.nBlockAlign = 2;
|
|
(*ppDS)->wfx.wBitsPerSample = 8;
|
|
|
|
if (!dsound) {
|
|
HANDLE32 hnd;
|
|
DWORD xid;
|
|
|
|
dsound = (*ppDS);
|
|
if (primarybuf == NULL) {
|
|
DSBUFFERDESC dsbd;
|
|
HRESULT hr;
|
|
|
|
dsbd.dwSize = sizeof(DSBUFFERDESC);
|
|
dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
|
|
dsbd.dwBufferBytes = 0;
|
|
dsbd.lpwfxFormat = &(dsound->wfx);
|
|
hr = IDirectSound_CreateSoundBuffer(*ppDS, &dsbd, &primarybuf, NULL);
|
|
if (hr != DS_OK) {
|
|
dsound->primary = primarybuf;
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hnd = CreateThread(NULL,0,DSOUND_thread,0,0,&xid);
|
|
}
|
|
return 0;
|
|
#else
|
|
MessageBox32A(0,"DirectSound needs the Open Sound System Driver, which has not been found by ./configure.","WINE DirectSound",MB_OK|MB_ICONSTOP);
|
|
return DSERR_NODRIVER;
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* DirectSound ClassFactory
|
|
*/
|
|
static HRESULT WINAPI
|
|
DSCF_QueryInterface(LPCLASSFACTORY this,REFIID riid,LPVOID *ppobj) {
|
|
char buf[80];
|
|
|
|
if (HIWORD(riid))
|
|
WINE_StringFromCLSID(riid,buf);
|
|
else
|
|
sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
|
|
FIXME(dsound,"(%p)->(%s,%p),stub!\n",this,buf,ppobj);
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
DSCF_AddRef(LPCLASSFACTORY this) {
|
|
return ++(this->ref);
|
|
}
|
|
|
|
static ULONG WINAPI DSCF_Release(LPCLASSFACTORY this) {
|
|
/* static class, won't be freed */
|
|
return --(this->ref);
|
|
}
|
|
|
|
static HRESULT WINAPI DSCF_CreateInstance(
|
|
LPCLASSFACTORY this,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
|
|
) {
|
|
char buf[80];
|
|
|
|
WINE_StringFromCLSID(riid,buf);
|
|
TRACE(dsound,"(%p)->(%p,%s,%p)\n",this,pOuter,buf,ppobj);
|
|
if (!memcmp(riid,&IID_IDirectSound,sizeof(IID_IDirectSound))) {
|
|
/* FIXME: reuse already created dsound if present? */
|
|
return DirectSoundCreate(riid,(LPDIRECTSOUND*)ppobj,pOuter);
|
|
}
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY this,BOOL32 dolock) {
|
|
FIXME(dsound,"(%p)->(%d),stub!\n",this,dolock);
|
|
return S_OK;
|
|
}
|
|
|
|
static IClassFactory_VTable DSCF_VTable = {
|
|
DSCF_QueryInterface,
|
|
DSCF_AddRef,
|
|
DSCF_Release,
|
|
DSCF_CreateInstance,
|
|
DSCF_LockServer
|
|
};
|
|
static IClassFactory DSOUND_CF = {&DSCF_VTable, 1 };
|
|
|
|
/*******************************************************************************
|
|
* DllGetClassObject [DSOUND.4]
|
|
* Retrieves class object from a DLL object
|
|
*
|
|
* NOTES
|
|
* Docs say returns STDAPI
|
|
*
|
|
* PARAMS
|
|
* rclsid [I] CLSID for the class object
|
|
* riid [I] Reference to identifier of interface for class object
|
|
* ppv [O] Address of variable to receive interface pointer for riid
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK
|
|
* Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
|
|
* E_UNEXPECTED
|
|
*/
|
|
DWORD WINAPI DSOUND_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
|
|
{
|
|
char buf[80],xbuf[80];
|
|
|
|
if (HIWORD(rclsid))
|
|
WINE_StringFromCLSID(rclsid,xbuf);
|
|
else
|
|
sprintf(xbuf,"<guid-0x%04x>",LOWORD(rclsid));
|
|
if (HIWORD(riid))
|
|
WINE_StringFromCLSID(riid,buf);
|
|
else
|
|
sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
|
|
WINE_StringFromCLSID(riid,xbuf);
|
|
TRACE(dsound, "(%p,%p,%p)\n", xbuf, buf, ppv);
|
|
if (!memcmp(riid,&IID_IClassFactory,sizeof(IID_IClassFactory))) {
|
|
*ppv = (LPVOID)&DSOUND_CF;
|
|
DSOUND_CF.lpvtbl->fnAddRef(&DSOUND_CF);
|
|
return S_OK;
|
|
}
|
|
FIXME(dsound, "(%p,%p,%p): no interface found.\n", xbuf, buf, ppv);
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* DllCanUnloadNow [DSOUND.3] Determines whether the DLL is in use.
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK
|
|
* Failure: S_FALSE
|
|
*/
|
|
DWORD WINAPI DllCanUnloadNow(void)
|
|
{
|
|
FIXME(dsound, "(void): stub\n");
|
|
return S_FALSE;
|
|
}
|