system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-31 10:41:12 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/multimedia/dsound.c
Marcus Meissner 1e319975d7 Small fixes.
1998-10-31 12:20:55 +00:00

1087 lines
29 KiB
C
Raw Blame History

/* DirectSound
*
* Copyright 1998 Marcus Meissner
*/
/*
* 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"
#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
static int audiofd = -1;
static LPDIRECTSOUND dsound = NULL;
static short playbuf[2048];
#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);
}
/*******************************************************************************
* 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
*/
static HRESULT WINAPI IDirectSoundBuffer_SetFormat(
LPDIRECTSOUNDBUFFER this,LPWAVEFORMATEX wfex
) {
memcpy(&(this->wfx),wfex,sizeof(this->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);
return 0;
}
static HRESULT WINAPI IDirectSoundBuffer_SetVolume(
LPDIRECTSOUNDBUFFER this,LONG vol
) {
TRACE(dsound,"(%p,%ld)\n",this,vol);
this->volume = vol;
this->volfac = ((double)vol+10000.0)/10000.0;
return 0;
}
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);
this->wfx.nSamplesPerSec = freq;
this->wfx.nAvgBytesPerSec = freq*this->wfx.nChannels*(this->wfx.wBitsPerSample/8);
return 0;
}
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->playpos = 0;
this->playflags = flags;
this->playing = 1;
return 0;
}
static HRESULT WINAPI IDirectSoundBuffer_Stop(LPDIRECTSOUNDBUFFER this) {
TRACE(dsound,"(%p)\n",this);
this->playing = 0;
this->writepos = 0; /* hmm */
return 0;
}
static DWORD WINAPI IDirectSoundBuffer_AddRef(LPDIRECTSOUNDBUFFER this) {
return ++(this->ref);
}
static DWORD WINAPI IDirectSoundBuffer_Release(LPDIRECTSOUNDBUFFER this) {
int i;
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) {
memcpy(
this->dsound->buffers+i,
this->dsound->buffers+i+1,
sizeof(LPDIRECTSOUNDBUFFER)*(this->dsound->nrofbuffers-i-1)
);
this->dsound->buffers = HeapReAlloc(GetProcessHeap(),0,this->dsound->buffers,sizeof(LPDIRECTSOUNDBUFFER)*this->dsound->nrofbuffers);
this->dsound->nrofbuffers--;
this->dsound->lpvtbl->fnRelease(this->dsound);
}
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);
memcpy(lpwf,&(this->wfx),wfsize);
if (wfwritten) *wfwritten = wfsize;
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;
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);
}
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 newpan
) {
TRACE(dsound,"(%p,%ld)\n",this,newpan);
this->pan = newpan;
return 0;
}
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
) {
/* FIXME(dsound,"(%p,%p,%ld,%p,%ld):stub\n", this,p1,x1,p2,x2); */
return 0;
}
static HRESULT WINAPI IDirectSoundBuffer_GetFrequency(
LPDIRECTSOUNDBUFFER this,LPDWORD freq
) {
TRACE(dsound,"(%p,%p)\n",this,freq);
*freq = this->wfx.nSamplesPerSec;
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
) {
caps->dwSize = sizeof(*caps);
caps->dwFlags = DSBCAPS_PRIMARYBUFFER|DSBCAPS_STATIC|DSBCAPS_CTRLALL|DSBCAPS_LOCSOFTWARE;
caps->dwBufferBytes = 65536;
caps->dwUnlockTransferRate = 0;
caps->dwPlayCpuOverhead = 0;
return DS_OK;
}
static HRESULT WINAPI IDirectSoundBuffer_QueryInterface(
LPDIRECTSOUNDBUFFER this,REFIID riid,LPVOID *ppobj
) {
char xbuf[50];
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;
}
WINE_StringFromCLSID(riid,xbuf);
TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
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
) {
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);
}
*ppdsb = (LPDIRECTSOUNDBUFFER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBuffer));
(*ppdsb)->ref =1;
(*ppdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,dsbd->dwBufferBytes);
(*ppdsb)->buflen = dsbd->dwBufferBytes;
(*ppdsb)->playpos = 0;
(*ppdsb)->writepos = 0;
(*ppdsb)->lpvtbl = &dsbvt;
(*ppdsb)->dsound = this;
(*ppdsb)->playing = 0;
(*ppdsb)->volfac = 1.0;
memcpy(&((*ppdsb)->dsbd),dsbd,sizeof(*dsbd));
/* 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);
if (dsbd->lpwfxFormat) dsbvt.fnSetFormat(*ppdsb,dsbd->lpwfxFormat);
return 0;
}
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;
dsbvt.fnSetFormat(*ppdsb,&(pdsb->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;
/* FIXME: query OSS */
caps->dwMinSecondarySampleRate = 22050;
caps->dwMaxSecondarySampleRate = 48000;
caps->dwPrimaryBuffers = 1;
/* FIXME: set the rest... hmm */
return 0;
}
static ULONG WINAPI IDirectSound_AddRef(LPDIRECTSOUND this) {
TRACE(dsound,"(%p), ref was %d\n",this,this->ref);
return ++(this->ref);
}
static ULONG WINAPI IDirectSound_Release(LPDIRECTSOUND this) {
TRACE(dsound,"(%p), ref was %d\n",this,this->ref);
if (!--(this->ref)) {
HeapFree(GetProcessHeap(),0,this);
dsound = NULL;
close(audiofd);audiofd = -1;
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];
WINE_StringFromCLSID(riid,xbuf);
TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
return E_FAIL;
}
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,
(void *)11
};
static int
DSOUND_setformat(LPWAVEFORMATEX wfex) {
int xx,channels,speed,format,nformat;
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 LPDSBPOSITIONNOTIFY
DSOUND_nextevent(IDirectSoundBuffer *dsb) {
int i;
if (dsb->nrofnotifies) {
for (i=0;i<dsb->nrofnotifies;i++) {
if (dsb->playpos<dsb->notifies[i].dwOffset)
break;
}
if (i==dsb->nrofnotifies)
i=0;
return dsb->notifies+i;
}
return NULL;
}
#define CHECK_EVENT \
if (nextevent && (dsb->playpos == nextevent->dwOffset)) { \
SetEvent(nextevent->hEventNotify); \
TRACE(dsound,"signalled event %d\n",nextevent->hEventNotify);\
nextevent = DSOUND_nextevent(dsb); \
}
static void
DSOUND_MixInBuffer(IDirectSoundBuffer *dsb) {
int j,buflen = dsb->buflen;
LPDSBPOSITIONNOTIFY nextevent;
int xdiff = dsb->wfx.nSamplesPerSec-dsound->wfx.nSamplesPerSec;
long Rvoldec, Lvoldec, samp;
long pan = dsb->pan;
{
double tmpr=dsb->volume-500;
double tmpl=tmpr;
if(pan>0) tmpl -= (double)pan;
else tmpr += (double)pan;
tmpl /= 1000.0;
tmpr /= 1000.0;
tmpl = pow(2.0, tmpl);
tmpr = pow(2.0, tmpr);
tmpl *= 65536; /* Set to the correct multiple times */
tmpr *= 65536; /* 65536 to be convenient for bit shifting */
tmpl += 0.5; /* Add .5 for rounding accuracy */
tmpr += 0.5;
Lvoldec = (long)tmpl;
Rvoldec = (long)tmpr;
}
/* End Insomnia's mod */
if (xdiff<0) xdiff=-xdiff;
if (xdiff>1500) {
WARN(dsound,"mixing in buffer of different frequency (%ld vs %ld), argh!\n",
dsb->wfx.nSamplesPerSec,dsound->wfx.nSamplesPerSec);
}
nextevent = DSOUND_nextevent(dsb);
TRACE(dsound,"(%d.%d.%d.%d)\n",dsound->wfx.wBitsPerSample,dsb->wfx.wBitsPerSample,dsound->wfx.nChannels,dsb->wfx.nChannels);
if (dsound->wfx.wBitsPerSample == 8) {
char *playbuf8 = (char*)playbuf;
if (dsb->wfx.wBitsPerSample == 8) {
unsigned char *xbuf = (unsigned char*)(dsb->buffer);
if (dsb->wfx.nChannels == 1) {
/* 8.1 -> 8.2 */
for (j=0;j<sizeof(playbuf)/2;j++) {
dsb->playpos=(dsb->playpos+1)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
/* Left Channel */
samp = xbuf[dsb->playpos];
samp *= Lvoldec;
samp >>= 16;
samp += playbuf8[(j<<1)];
if(samp > 127L) samp = 127L;
else if(samp < -128L) samp = -128L;
playbuf8[(j<<1)] = (short)samp;
/* Right Channel */
samp = xbuf[dsb->playpos];
samp *= Rvoldec;
samp >>= 16;
samp += playbuf8[(j<<1)+1];
if(samp > 127L) samp = 127L;
else if(samp < -128L) samp = -128L;
playbuf8[(j<<1)+1] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
} else {
/* 8.2 -> 8.2 */
for (j=0;j<sizeof(playbuf);j++) {
dsb->playpos=(dsb->playpos+1)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
samp = xbuf[dsb->playpos];
/* Right Channel */
if(j&1) samp *= Rvoldec;
/* Left Channel */
else samp *= Lvoldec;
samp >>= 16;
samp += playbuf8[j];
if(samp > 127L) samp = 127L;
else if(samp < -128L) samp = -128L;
playbuf8[j] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
}
} else { /* 16 */
short *xbuf = (short*)(dsb->buffer);
if (dsb->wfx.nChannels == 1) {
/* 16.1 -> 8.2 */
for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0])/2;j++) {
dsb->playpos=(dsb->playpos+2)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
/* Left Channel */
samp = xbuf[dsb->playpos>>1];
samp *= Lvoldec;
samp >>= 24;
samp += playbuf8[(j<<1)];
if(samp > 127L) samp = 127L;
else if(samp < -128L) samp = -128L;
playbuf8[(j<<1)] = (short)samp;
/* Right Channel */
samp = xbuf[dsb->playpos>>1];
samp *= Rvoldec;
samp >>= 24;
samp += playbuf8[(j<<1)+1];
if(samp > 127L) samp = 127L;
else if(samp < -128L) samp = -128L;
playbuf8[(j<<1)+1] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
} else {
/* 16.2 -> 8.2 */
for (j=0;j<sizeof(playbuf);j++) {
dsb->playpos=(dsb->playpos+2)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
samp = xbuf[dsb->playpos>>1];
/* Right Channel */
if(j&1) samp *= Rvoldec;
/* Left Channel */
else samp *= Lvoldec;
samp >>= 24;
samp += playbuf8[j];
if(samp > 127L) samp = 127L;
else if(samp < -128L) samp = -128L;
playbuf8[j] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
}
}
} else { /* 16 bit */
if (dsb->wfx.wBitsPerSample == 8) {
/* unsigned char *xbuf = (unsigned char*)(dsb->buffer); */
char *xbuf = dsb->buffer;
if (dsb->wfx.nChannels == 1) {
/* 8.1 -> 16.2 */
WARN(dsound,"Mixing 8-bit stereo into 16!!\n");
for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0])/2;j++) {
dsb->playpos=(dsb->playpos+1)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
/* Left Channel */
samp = xbuf[dsb->playpos];
samp *= Lvoldec;
samp >>= 8;
samp += playbuf[(j<<1)];
if(samp > 32767L) samp = 32767L;
else if(samp < -32768L) samp = -32768L;
playbuf[(j<<1)] = (short)samp;
/* Right Channel */
samp = xbuf[dsb->playpos];
samp *= Rvoldec;
samp >>= 8;
samp += playbuf[(j<<1)+1];
if(samp > 32767L) samp = 32767L;
else if(samp < -32768L) samp = -32768L;
playbuf[(j<<1)+1] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
} else {
/* 8.2 -> 16.2 */
for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0]);j++) {
dsb->playpos=(dsb->playpos+1)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
samp = xbuf[dsb->playpos];
/* Right Channel */
if(j&1) samp *= Rvoldec;
/* Left Channel */
else samp *= Lvoldec;
samp >>= 8;
samp += playbuf[j];
if(samp > 32767L) samp = 32767L;
else if(samp < -32768L) samp = -32768L;
playbuf[j] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
}
} else { /* 16 */
/* 16.1 -> 16.2 */
short *xbuf = (short*)(dsb->buffer);
if (dsb->wfx.nChannels == 1) {
for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0])/2;j++) {
dsb->playpos=(dsb->playpos+2)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
/* Left Channel */
samp = xbuf[dsb->playpos>>1];
samp *= Lvoldec;
samp >>= 16;
samp += playbuf[(j<<1)];
if(samp > 32767L) samp = 32767L;
else if(samp < -32768L) samp = -32768L;
playbuf[(j<<1)] = (short)samp;
/* Right Channel */
samp = xbuf[dsb->playpos>>1];
samp *= Rvoldec;
samp >>= 16;
samp += playbuf[(j<<1)+1];
if(samp > 32767L) samp = 32767L;
else if(samp < -32768L) samp = -32768L;
playbuf[(j<<1)+1] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
} else {
for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0]);j++) {
dsb->playpos=(dsb->playpos+2)%buflen;
if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
dsb->playing = 0;
dsb->playpos = buflen;
return;
}
/* Insomnia- volume, panning, and correcting against wrap */
samp = xbuf[dsb->playpos>>1];
/* Right Channel */
if(j&1) samp *= Rvoldec;
/* Left Channel */
else samp *= Lvoldec;
samp >>= 16;
samp += playbuf[j];
if(samp > 32767L) samp = 32767L;
else if(samp < -32768L) samp = -32768L;
playbuf[j] = (short)samp;
/* End Insomnia's mod */
CHECK_EVENT
}
}
}
}
}
static DWORD WINAPI
DSOUND_thread(LPVOID arg) {
int res,i,curleft,playing,haveprimary = 0;
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 (!dsound->nrofbuffers) {
/* no soundbuffer yet... wait. */
Sleep(1000);
dsound->lpvtbl->fnRelease(dsound);
continue;
}
memset(playbuf,0,sizeof(playbuf));
playing = 0;
haveprimary = 0;
for (i=dsound->nrofbuffers;i--;) {
IDirectSoundBuffer *dsb = dsound->buffers[i];
if (!dsb || !dsb->lpvtbl)
continue;
dsb->lpvtbl->fnAddRef(dsb);
if (dsb->playing && dsb->buflen)
playing++;
if (dsb->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
haveprimary = 1;
if (memcmp(&dsound->wfx,&(dsb->wfx),sizeof(dsound->wfx))) {
DSOUND_setformat(&(dsb->wfx));
memcpy(&dsound->wfx,&(dsb->wfx),sizeof(dsb->wfx));
}
}
dsb->lpvtbl->fnRelease(dsb);
}
/* We have just one playbuffer, so use its format */
if ((playing==1) && !haveprimary) {
for (i=dsound->nrofbuffers;i--;) {
IDirectSoundBuffer *dsb = dsound->buffers[i];
dsb->lpvtbl->fnAddRef(dsb);
if (dsb->playing && dsb->buflen) {
if (memcmp(&dsound->wfx,&(dsb->wfx),sizeof(dsound->wfx))) {
DSOUND_setformat(&(dsb->wfx));
memcpy(&dsound->wfx,&(dsb->wfx),sizeof(dsb->wfx));
}
}
dsb->lpvtbl->fnRelease(dsb);
}
}
for (i=dsound->nrofbuffers;i--;) {
IDirectSoundBuffer *dsb = dsound->buffers[i];
if (!dsb || !dsb->lpvtbl)
continue;
dsb->lpvtbl->fnAddRef(dsb);
if (dsb->buflen && dsb->playing)
DSOUND_MixInBuffer(dsb);
dsb->lpvtbl->fnRelease(dsb);
}
dsound->lpvtbl->fnRelease(dsound);
fputc('0'+playing,stderr);
curleft = 0;
while (curleft < sizeof(playbuf)) {
res = write(audiofd,(LPBYTE)playbuf+curleft,sizeof(playbuf)-curleft);
if (res==-1) {
if (errno==EINTR)
continue;
perror("write audiofd");
ExitThread(0);
break;
}
curleft+=res;
}
}
ExitThread(0);
}
#endif /* HAVE_OSS */
HRESULT WINAPI DirectSoundCreate(LPGUID lpGUID,LPDIRECTSOUND *ppDS,IUnknown *pUnkOuter ) {
int xx;
if (lpGUID)
TRACE(dsound,"(%p,%p,%p)\n",lpGUID,ppDS,pUnkOuter);
#ifdef HAVE_OSS
if (audiofd>=0)
return DSERR_ALLOCATED;
audiofd = open("/dev/audio",O_WRONLY);
if (audiofd==-1) {
perror("open /dev/audio");
audiofd=0;
return DSERR_NODRIVER;
}
xx=0x0002000c;
if (-1==ioctl(audiofd,SNDCTL_DSP_SETFRAGMENT,&xx))
perror("ioctl SETFRAGMENT");
/*
TRACE(dsound,"SETFRAGMENT. count is now %d, fragsize is %d\n",
(xx>>16)+1,xx&0xffff
);
*/
*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;
DSOUND_setformat(&((*ppDS)->wfx));
if (!dsound) {
HANDLE32 hnd;
DWORD xid;
dsound = (*ppDS);
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
}
/*******************************************************************************
* 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 DllGetClassObject( REFCLSID rclsid, REFIID riid, LPVOID *ppv )
{
FIXME(dsound, "(%p,%p,%p): stub\n", rclsid, riid, ppv);
return S_OK;
}
/*******************************************************************************
* 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;
}
Reference in a new issue View git blame Copy permalink