10 Dec
2001
10 Dec
'01
8:23 p.m.
could the people who had issues with the latest OSS patch(es) test if this one fixes all their issues ?
TIA
A+
--
---------------
Eric Pouech (http://perso.wanadoo.fr/eric.pouech/)
"The future will be better tomorrow", Vice President Dan Quayle
Index: dlls/winmm/wineoss/audio.c
===================================================================
RCS file: /usr/share/cvs/cvsroot/wine/wine/dlls/winmm/wineoss/audio.c,v
retrieving revision 1.47
diff -u -r1.47 audio.c
--- dlls/winmm/wineoss/audio.c 2001/11/19 02:10:50 1.47
+++ dlls/winmm/wineoss/audio.c 2001/12/10 20:15:30
@@ -82,6 +82,7 @@
#define WINE_WM_RESETTING (WM_USER + 3)
#define WINE_WM_CLOSING (WM_USER + 4)
#define WINE_WM_HEADER (WM_USER + 5)
+#define WINE_WM_UPDATE (WM_USER + 6)
typedef struct {
int msg; /* message identifier */
@@ -89,9 +90,9 @@
HANDLE hEvent; /* if message is synchronous, handle of event for synchro */
} OSS_MSG;
-/* implement a in process message ring for better performance
+/* implement an in-process message ring for better performance
* (compared to passing thru the server)
- * this ring will be used by both the input & output plauback
+ * this ring will be used by the input (resp output) record (resp playback) routine
*/
typedef struct {
#define OSS_RING_BUFFER_SIZE 30
@@ -105,39 +106,32 @@
typedef struct {
int unixdev;
volatile int state; /* one of the WINE_WS_ manifest constants */
+ WAVEOPENDESC waveDesc;
+ WORD wFlags;
+ PCMWAVEFORMAT format;
+ WAVEOUTCAPSA caps;
+
+ /* OSS information */
DWORD dwFragmentSize; /* size of OSS buffer fragment */
- DWORD dwBufferSize; /* size of whole OSS buffer in bytes
- * used to compute dwPlayedTotal from dwWrittenTotal and
- * ioctl GETOSPACE info
- */
+ DWORD dwBufferSize; /* size of whole OSS buffer in bytes */
WORD uWaitForFragments; /* The number of OSS buffer fragments we would like to be free
* before trying to write to the DSP
*/
- DWORD dwMillisPerFragment; /* The number of milliseconds of sound in each OSS buffer
- * fragment
- */
- WAVEOPENDESC waveDesc;
- WORD wFlags;
- PCMWAVEFORMAT format;
LPWAVEHDR lpQueuePtr; /* start of queued WAVEHDRs (waiting to be notified) */
LPWAVEHDR lpPlayPtr; /* start of not yet fully played buffers */
+ DWORD dwPartialOffset; /* Offset of not yet written bytes in lpPlayPtr */
- /* info on current lpPlayPtr->lpWaveHdr */
- LPSTR lpPartialData; /* Data still to write on current wavehdr */
- DWORD dwPartialBytes; /* number of bytes to write to end current wavehdr */
-
LPWAVEHDR lpLoopPtr; /* pointer of first buffer in loop, if any */
DWORD dwLoops; /* private copy of loop counter */
- DWORD dwPlayedTotal; /* number of bytes played since opening */
- DWORD dwWrittenTotal; /* number of bytes written since opening */
+ DWORD dwPlayedTotal; /* number of bytes actually played since opening */
+ DWORD dwWrittenTotal; /* number of bytes written to OSS buffer since opening */
/* synchronization stuff */
HANDLE hStartUpEvent;
HANDLE hThread;
DWORD dwThreadID;
OSS_MSG_RING msgRing;
- WAVEOUTCAPSA caps;
/* DirectSound stuff */
LPBYTE mapping;
@@ -174,7 +168,8 @@
"WINE_WM_RESTARTING",
"WINE_WM_RESETTING",
"WINE_WM_CLOSING",
- "WINE_WM_HEADER" };
+ "WINE_WM_HEADER",
+ "WINE_WM_UPDATE" };
/*======================================================================*
* Low level WAVE implementation *
@@ -378,56 +373,6 @@
return 0;
}
-/**************************************************************************
- * OSS_NotifyClient [internal]
- */
-static DWORD OSS_NotifyClient(UINT wDevID, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
-{
- TRACE("wDevID = %04X wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n",wDevID, wMsg, dwParam1, dwParam2);
-
- switch (wMsg) {
- case WOM_OPEN:
- case WOM_CLOSE:
- case WOM_DONE:
- if (wDevID >= MAX_WAVEOUTDRV) return MCIERR_INTERNAL;
-
- if (WOutDev[wDevID].wFlags != DCB_NULL &&
- !DriverCallback(WOutDev[wDevID].waveDesc.dwCallback,
- WOutDev[wDevID].wFlags,
- WOutDev[wDevID].waveDesc.hWave,
- wMsg,
- WOutDev[wDevID].waveDesc.dwInstance,
- dwParam1,
- dwParam2)) {
- WARN("can't notify client !\n");
- return MMSYSERR_NOERROR;
- }
- break;
-
- case WIM_OPEN:
- case WIM_CLOSE:
- case WIM_DATA:
- if (wDevID >= MAX_WAVEINDRV) return MCIERR_INTERNAL;
-
- if (WInDev[wDevID].wFlags != DCB_NULL &&
- !DriverCallback(WInDev[wDevID].waveDesc.dwCallback,
- WInDev[wDevID].wFlags,
- WInDev[wDevID].waveDesc.hWave,
- wMsg,
- WInDev[wDevID].waveDesc.dwInstance,
- dwParam1,
- dwParam2)) {
- WARN("can't notify client !\n");
- return MMSYSERR_NOERROR;
- }
- break;
- default:
- FIXME("Unknown CB message %u\n", wMsg);
- break;
- }
- return 0;
-}
-
static int OSS_InitRingMessage(OSS_MSG_RING* omr)
{
omr->msg_toget = 0;
@@ -497,24 +442,38 @@
*======================================================================*/
/**************************************************************************
- * updatePlayedTotal [internal]
- *
- * Calculates wwo->dwPlayed total from wwo->dwWrittenTotal and the amount
- * still remaining in the OSS buffer.
+ * wodNotifyClient [internal]
*/
-static DWORD updatePlayedTotal( WINE_WAVEOUT* wwo )
+static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
{
- audio_buf_info info;
-
- if (ioctl(wwo->unixdev, SNDCTL_DSP_GETOSPACE, &info) < 0) {
- ERR("ioctl failed (%s)\n", strerror(errno));
- return wwo->dwPlayedTotal;
+ TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
+
+ switch (wMsg) {
+ case WOM_OPEN:
+ case WOM_CLOSE:
+ case WOM_DONE:
+ if (wwo->wFlags != DCB_NULL &&
+ !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, wwo->waveDesc.hWave,
+ wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
+ WARN("can't notify client !\n");
+ return MMSYSERR_ERROR;
+ }
+ break;
+ default:
+ FIXME("Unknown CB message %u\n", wMsg);
+ return MMSYSERR_INVALPARAM;
}
-
- wwo->dwPlayedTotal=wwo->dwWrittenTotal-( wwo->dwBufferSize - info.bytes );
- return wwo->dwPlayedTotal;
+ return MMSYSERR_NOERROR;
}
+/**************************************************************************
+ * wodUpdatePlayedTotal [internal]
+ *
+ */
+static void wodUpdatePlayedTotal(WINE_WAVEOUT* wwo, DWORD availInQ)
+{
+ wwo->dwPlayedTotal = wwo->dwWrittenTotal - (wwo->dwBufferSize - availInQ);
+}
/**************************************************************************
* wodPlayer_BeginWaveHdr [internal]
@@ -523,12 +482,11 @@
* If the specified wave header is a begin loop and we're not already in
* a loop, setup the loop.
*/
-static void wodPlayer_BeginWaveHdr( WINE_WAVEOUT* wwo,
- LPWAVEHDR lpWaveHdr )
+static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
{
- wwo->lpPlayPtr=lpWaveHdr;
+ wwo->lpPlayPtr = lpWaveHdr;
- if( !lpWaveHdr ) return;
+ if (!lpWaveHdr) return;
if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
if (wwo->lpLoopPtr) {
@@ -541,6 +499,7 @@
wwo->dwLoops = lpWaveHdr->dwLoops;
}
}
+ wwo->dwPartialOffset = 0;
}
/**************************************************************************
@@ -550,8 +509,9 @@
*/
static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEOUT* wwo)
{
- LPWAVEHDR lpWaveHdr=wwo->lpPlayPtr;
+ LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
+ wwo->dwPartialOffset = 0;
if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
/* We're at the end of a loop, loop if required */
if (--wwo->dwLoops > 0) {
@@ -564,17 +524,17 @@
* the opening one or for both ???
* code assumes for closing loop only
*/
- wwo->lpLoopPtr = NULL;
- wodPlayer_BeginWaveHdr( wwo, lpWaveHdr );
} else {
- wwo->lpLoopPtr = NULL;
- wodPlayer_BeginWaveHdr( wwo, lpWaveHdr=lpWaveHdr->lpNext );
- }
+ lpWaveHdr = lpWaveHdr->lpNext;
+ }
+ wwo->lpLoopPtr = NULL;
+ wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
}
} else {
/* We're not in a loop. Advance to the next wave header */
- wodPlayer_BeginWaveHdr( wwo, lpWaveHdr=lpWaveHdr->lpNext );
+ wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
}
+
return lpWaveHdr;
}
@@ -584,11 +544,13 @@
* This is based on the number of fragments we want to be clear before
* writing and the number of free fragments we already have.
*/
-static DWORD wodPlayer_DSPWait( WINE_WAVEOUT *wwo, WORD uFreeFragments )
+static DWORD wodPlayer_DSPWait(const WINE_WAVEOUT *wwo, DWORD availInQ)
{
- return (uFreeFragments>wwo->uWaitForFragments)?1:
- wwo->dwMillisPerFragment*
- (wwo->uWaitForFragments-uFreeFragments);
+ DWORD uFreeFragments = availInQ / wwo->dwFragmentSize;
+
+ return (uFreeFragments >= wwo->uWaitForFragments)
+ ? 1 : (wwo->dwFragmentSize * 1000 / wwo->format.wf.nAvgBytesPerSec) *
+ (wwo->uWaitForFragments - uFreeFragments);
}
/**************************************************************************
@@ -598,20 +560,15 @@
* This is based on the number of bytes remaining to be written in the
* wave.
*/
-static DWORD wodPlayer_NotifyWait( WINE_WAVEOUT *wwo, LPWAVEHDR lpWaveHdr )
+static DWORD wodPlayer_NotifyWait(const WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
{
DWORD dwMillis;
- if( lpWaveHdr->reserved<wwo->dwPlayedTotal ) {
- dwMillis=1;
+ if (lpWaveHdr->reserved < wwo->dwPlayedTotal) {
+ dwMillis = 1;
} else {
- dwMillis=(lpWaveHdr->reserved-wwo->dwPlayedTotal) *
- wwo->dwMillisPerFragment / wwo->dwFragmentSize;
- TRACE( "wait for %lu bytes = %lu\n",
- (lpWaveHdr->reserved-wwo->dwPlayedTotal),
- dwMillis );
- if( dwMillis < 1 )
- dwMillis=1;
+ dwMillis = (lpWaveHdr->reserved - wwo->dwPlayedTotal) * 1000 / wwo->format.wf.nAvgBytesPerSec;
+ if (!dwMillis) dwMillis = 1;
}
return dwMillis;
@@ -621,26 +578,28 @@
/**************************************************************************
* wodPlayer_WriteMaxFrags [internal]
* Writes the maximum number of bytes possible to the DSP and returns
- * the number of bytes written. Also updates fragments in dspspace.
+ * the number of bytes written.
*/
-static DWORD wodPlayer_WriteMaxFrags( WINE_WAVEOUT *wwo, LPSTR lpData,
- DWORD dwLength,
- audio_buf_info* dspspace )
-{
- /* Only attempt to write to free fragments */
- int maxWrite=dspspace->fragments*dspspace->fragsize;
- int toWrite=min(dwLength,maxWrite);
-
- int written=write(wwo->unixdev, lpData, toWrite);
-
- TRACE("wrote %d of %lu bytes\n",
- written, dwLength );
- if( written > 0 ) {
- /* Keep a count of the total bytes written to the DSP */
- wwo->dwWrittenTotal+=written;
- /* reduce the number of free fragments */
- dspspace->fragments -= (written/dspspace->fragsize)+(written%dspspace->fragsize>0);
+static int wodPlayer_WriteMaxFrags(WINE_WAVEOUT* wwo, DWORD* bytes)
+{
+ /* Only attempt to write to free bytes */
+ DWORD dwLength = wwo->lpPlayPtr->dwBufferLength - wwo->dwPartialOffset;
+ int toWrite = min(dwLength, *bytes);
+ int written;
+
+ TRACE("Writing wavehdr %p.%lu\n", wwo->lpPlayPtr, wwo->dwPartialOffset);
+ written = write(wwo->unixdev, wwo->lpPlayPtr->lpData + wwo->dwPartialOffset, toWrite);
+ if (written <= 0) return written;
+
+ if (written >= dwLength) {
+ /* If we wrote it all, skip to the next header */
+ wodPlayer_PlayPtrNext(wwo);
+ } else {
+ /* Remove the amount written */
+ wwo->dwPartialOffset += written;
}
+ *bytes -= written;
+ wwo->dwWrittenTotal += written;
return written;
}
@@ -654,37 +613,30 @@
* we notify all wavehdrs and remove them all from the queue even if they
* are unplayed or part of a loop.
*/
-static DWORD wodPlayer_NotifyCompletions( WINE_WAVEOUT* wwo, WORD uDevID, BOOL force)
+static DWORD wodPlayer_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
{
LPWAVEHDR lpWaveHdr;
- updatePlayedTotal(wwo);
/* Start from lpQueuePtr and keep notifying until:
* - we hit an unwritten wavehdr
* - we hit the beginning of a running loop
* - we hit a wavehdr which hasn't finished playing
*/
- while( (lpWaveHdr=wwo->lpQueuePtr) &&
- (force ||
- (lpWaveHdr != wwo->lpPlayPtr &&
- lpWaveHdr != wwo->lpLoopPtr &&
- lpWaveHdr->reserved <= wwo->dwPlayedTotal ))) {
+ while ((lpWaveHdr = wwo->lpQueuePtr) &&
+ (force ||
+ (lpWaveHdr != wwo->lpPlayPtr &&
+ lpWaveHdr != wwo->lpLoopPtr &&
+ lpWaveHdr->reserved <= wwo->dwPlayedTotal))) {
wwo->lpQueuePtr = lpWaveHdr->lpNext;
lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
lpWaveHdr->dwFlags |= WHDR_DONE;
- TRACE("Notifying client with %p\n", lpWaveHdr);
- if (OSS_NotifyClient(uDevID, WOM_DONE, (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR) {
- WARN("can't notify client !\n");
- }
+ wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
}
- return ( lpWaveHdr &&
- lpWaveHdr != wwo->lpPlayPtr &&
- lpWaveHdr != wwo->lpLoopPtr ) ?
- wodPlayer_NotifyWait( wwo, lpWaveHdr ) :
- 0 ;
+ return (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != wwo->lpLoopPtr) ?
+ wodPlayer_NotifyWait(wwo, lpWaveHdr) : INFINITE;
}
/**************************************************************************
@@ -692,10 +644,10 @@
*
* wodPlayer helper. Resets current output stream.
*/
-static void wodPlayer_Reset(WINE_WAVEOUT* wwo, WORD uDevID, BOOL reset)
+static void wodPlayer_Reset(WINE_WAVEOUT* wwo, BOOL reset)
{
/* updates current notify list */
- wodPlayer_NotifyCompletions(wwo, uDevID, FALSE);
+ wodPlayer_NotifyCompletions(wwo, FALSE);
/* flush all possible output */
if (ioctl(wwo->unixdev, SNDCTL_DSP_RESET, 0) == -1) {
@@ -706,17 +658,16 @@
}
/* Clear partial wavehdr */
- wwo->dwPartialBytes=0;
- wwo->lpPartialData=NULL;
+ wwo->dwPartialOffset = 0;
if (reset) {
/* empty notify list */
- wodPlayer_NotifyCompletions(wwo, uDevID, TRUE);
+ wodPlayer_NotifyCompletions(wwo, TRUE);
wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
wwo->state = WINE_WS_STOPPED;
wwo->dwPlayedTotal = 0;
- wwo->dwWrittenTotal = 0;
+ wwo->dwWrittenTotal = 0;
} else {
/* FIXME: this is not accurate when looping, but can be do better ? */
wwo->lpPlayPtr = (wwo->lpLoopPtr) ? wwo->lpLoopPtr : wwo->lpQueuePtr;
@@ -725,41 +676,9 @@
}
/**************************************************************************
- * wodPlayer_AwaitEvent [internal]
- * Wait for a command to be sent to the wodPlayer or for time to pass
- * until wodPlayer needs to do something again.
- */
-static void wodPlayer_AwaitEvent( WINE_WAVEOUT* wwo,
- DWORD dwNextFeedTime,
- DWORD dwNextNotifyTime )
-{
- DWORD dwSleepTime;
-
- /** Wait for the shortest time before an action is required. If there
- * are no pending actions, wait forever for a command.
- */
- if( dwNextFeedTime == 0 ) {
- if( dwNextNotifyTime == 0 )
- dwSleepTime=INFINITE;
- else
- dwSleepTime=dwNextNotifyTime;
- } else {
- if( dwNextNotifyTime == 0 )
- dwSleepTime=dwNextFeedTime;
- else
- dwSleepTime=min( dwNextFeedTime, dwNextNotifyTime );
- }
- TRACE( "waiting %lu millis (%lu,%lu)\n", dwSleepTime,
- dwNextFeedTime,dwNextNotifyTime );
- WaitForSingleObject(wwo->msgRing.msg_event, dwSleepTime);
- TRACE( "wait returned\n");
-
-}
-
-/**************************************************************************
* wodPlayer_ProcessMessages [internal]
*/
-static void wodPlayer_ProcessMessages( WINE_WAVEOUT* wwo, WORD uDevID )
+static void wodPlayer_ProcessMessages(WINE_WAVEOUT* wwo)
{
LPWAVEHDR lpWaveHdr;
int msg;
@@ -767,11 +686,10 @@
HANDLE ev;
while (OSS_RetrieveRingMessage(&wwo->msgRing, &msg, ¶m, &ev)) {
- TRACE( "Received %s %lx\n",
- wodPlayerCmdString[msg-WM_USER-1], param );
+ TRACE("Received %s %lx\n", wodPlayerCmdString[msg - WM_USER - 1], param);
switch (msg) {
case WINE_WM_PAUSING:
- wodPlayer_Reset(wwo, uDevID, FALSE);
+ wodPlayer_Reset(wwo, FALSE);
wwo->state = WINE_WS_PAUSED;
SetEvent(ev);
break;
@@ -788,12 +706,13 @@
for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
*wh = lpWaveHdr;
}
- wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
+ if (!wwo->lpPlayPtr)
+ wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
if (wwo->state == WINE_WS_STOPPED)
wwo->state = WINE_WS_PLAYING;
break;
case WINE_WM_RESETTING:
- wodPlayer_Reset(wwo, uDevID, TRUE);
+ wodPlayer_Reset(wwo, TRUE);
SetEvent(ev);
break;
case WINE_WM_CLOSING:
@@ -804,6 +723,17 @@
SetEvent(ev);
ExitThread(0);
/* shouldn't go here */
+ case WINE_WM_UPDATE:
+ {
+ audio_buf_info info;
+
+ if (ioctl(wwo->unixdev, SNDCTL_DSP_GETOSPACE, &info) < 0) {
+ ERR("ioctl failed (%s)\n", strerror(errno));
+ } else {
+ wodUpdatePlayedTotal(wwo, info.bytes);
+ }
+ }
+ break;
default:
FIXME("unknown message %d\n", msg);
break;
@@ -816,77 +746,45 @@
* Feed as much sound data as we can into the DSP and return the number of
* milliseconds before it will be necessary to feed the DSP again.
*/
-static DWORD wodPlayer_FeedDSP( WINE_WAVEOUT* wwo )
+static DWORD wodPlayer_FeedDSP(WINE_WAVEOUT* wwo)
{
- LPWAVEHDR lpWaveHdr=wwo->lpPlayPtr;
- DWORD written=0;
- DWORD bytesToWrite;
audio_buf_info dspspace;
+ DWORD availInQ;
- /* Read output space info so we know how much writing to do */
if (ioctl(wwo->unixdev, SNDCTL_DSP_GETOSPACE, &dspspace) < 0) {
- ERR("IOCTL can't 'SNDCTL_DSP_GETOSPACE' !\n");
+ ERR("IOCTL can't 'SNDCTL_DSP_GETOSPACE' !\n");
+ return INFINITE;
}
+ TRACE("fragments=%d/%d, fragsize=%d, bytes=%d\n",
+ dspspace.fragments, dspspace.fragstotal, dspspace.fragsize, dspspace.bytes);
- TRACE( "fragments=%d, fragsize=%d, fragstotal=%d, bytes=%d\n",
- dspspace.fragments, dspspace.fragsize,
- dspspace.fragstotal, dspspace.bytes );
+ availInQ = dspspace.bytes;
+ wodUpdatePlayedTotal(wwo, availInQ);
- /* Do nothing if the DSP isn't hungry */
- if( dspspace.fragments==0 ) {
- return wodPlayer_DSPWait(wwo,dspspace.fragments);
- }
-
- /* If there's a partially written wavehdr, feed more of it
- * -------------------------------------------------------
- */
- bytesToWrite=wwo->dwPartialBytes;
- if( bytesToWrite > 0 ) {
- TRACE("partial write %lu bytes at %p\n",
- wwo->dwPartialBytes,
- wwo->lpPartialData );
- written=wodPlayer_WriteMaxFrags( wwo, wwo->lpPartialData,
- bytesToWrite,
- &dspspace );
- if( written >= bytesToWrite ) {
- /* If we wrote it all, skip to the next header */
- wwo->dwPartialBytes=0;
- wwo->lpPartialData=NULL;
- lpWaveHdr=wodPlayer_PlayPtrNext( wwo );
- } else {
- /* Remove the amount written */
- wwo->lpPartialData+=written;
- wwo->dwPartialBytes-=written;
- }
+ /* input queue empty and output buffer with less than one fragment to play */
+ if (!wwo->lpPlayPtr && wwo->dwBufferSize < availInQ + 2 * wwo->dwFragmentSize) {
+ TRACE("Run out of wavehdr:s... flushing\n");
+ ioctl(wwo->unixdev, SNDCTL_DSP_SYNC, 0);
+ wodUpdatePlayedTotal(wwo, wwo->dwBufferSize);
+ return INFINITE;
}
- /* Feed wavehdrs until we run out of wavehdrs or DSP space
- * -------------------------------------------------------
- */
- while( lpWaveHdr && dspspace.fragments > 0 ) {
- TRACE( "Writing wavehdr %p %lu bytes\n", lpWaveHdr,
- lpWaveHdr->dwBufferLength );
+ /* no more room... no need to try to feed */
+ if (dspspace.fragments == 0) return wodPlayer_DSPWait(wwo, 0);
- /* note the value that dwPlayedTotal will be when this
- * wave finishes playing
- */
- lpWaveHdr->reserved=wwo->dwWrittenTotal+lpWaveHdr->dwBufferLength;
+ /* Feed from partial wavehdr */
+ if (wwo->lpPlayPtr && wwo->dwPartialOffset != 0) {
+ wodPlayer_WriteMaxFrags(wwo, &availInQ);
+ }
- written=wodPlayer_WriteMaxFrags( wwo, lpWaveHdr->lpData,
- lpWaveHdr->dwBufferLength,
- &dspspace );
- /* If it's all written, on to the next one, else remember the
- * partial write for next FeedDSP call.
- */
- if( written >= lpWaveHdr->dwBufferLength ) {
- lpWaveHdr=wodPlayer_PlayPtrNext( wwo );
- } else {
- wwo->dwPartialBytes=lpWaveHdr->dwBufferLength-written;
- wwo->lpPartialData=lpWaveHdr->lpData+written;
- }
+ /* Feed wavehdrs until we run out of wavehdrs or DSP space */
+ if (wwo->dwPartialOffset == 0) while (wwo->lpPlayPtr && availInQ > 0) {
+ /* note the value that dwPlayedTotal will return when this wave finishes playing */
+ wwo->lpPlayPtr->reserved = wwo->dwWrittenTotal + wwo->lpPlayPtr->dwBufferLength;
+ wodPlayer_WriteMaxFrags(wwo, &availInQ);
}
- return lpWaveHdr ? wodPlayer_DSPWait(wwo,dspspace.fragments) : 0 ;
+ return wodPlayer_DSPWait(wwo, availInQ);
}
@@ -897,20 +795,26 @@
{
WORD uDevID = (DWORD)pmt;
WINE_WAVEOUT* wwo = (WINE_WAVEOUT*)&WOutDev[uDevID];
- DWORD dwNextFeedTime=0; /* Time before DSP needs feeding */
- DWORD dwNextNotifyTime=0; /* Time before next wave completion */
+ DWORD dwNextFeedTime = INFINITE; /* Time before DSP needs feeding */
+ DWORD dwNextNotifyTime = INFINITE; /* Time before next wave completion */
+ DWORD dwSleepTime;
- wwo->state=WINE_WS_STOPPED;
- SetEvent( wwo->hStartUpEvent );
+ wwo->state = WINE_WS_STOPPED;
+ SetEvent(wwo->hStartUpEvent);
- for(;;) {
- wodPlayer_AwaitEvent(wwo,dwNextFeedTime,dwNextNotifyTime);
- wodPlayer_ProcessMessages(wwo,uDevID);
- if( wwo->state== WINE_WS_PLAYING ) {
- dwNextFeedTime=wodPlayer_FeedDSP(wwo);
- dwNextNotifyTime=wodPlayer_NotifyCompletions(wwo,uDevID,FALSE);
+ for (;;) {
+ /** Wait for the shortest time before an action is required. If there
+ * are no pending actions, wait forever for a command.
+ */
+ dwSleepTime = min(dwNextFeedTime, dwNextNotifyTime);
+ TRACE("waiting %lums (%lu,%lu)\n", dwSleepTime, dwNextFeedTime, dwNextNotifyTime);
+ WaitForSingleObject(wwo->msgRing.msg_event, dwSleepTime);
+ wodPlayer_ProcessMessages(wwo);
+ if (wwo->state == WINE_WS_PLAYING) {
+ dwNextFeedTime = wodPlayer_FeedDSP(wwo);
+ dwNextNotifyTime = wodPlayer_NotifyCompletions(wwo, FALSE);
} else {
- dwNextFeedTime=dwNextNotifyTime=0;
+ dwNextFeedTime = dwNextNotifyTime = INFINITE;
}
}
}
@@ -1039,7 +943,7 @@
if (dsp_stereo != (wwo->format.wf.nChannels > 1) ? 1 : 0)
ERR("Can't set stereo to %u (%d)\n",
(wwo->format.wf.nChannels > 1) ? 1 : 0, dsp_stereo);
- if (!NEAR_MATCH(sample_rate,wwo->format.wf.nSamplesPerSec))
+ if (!NEAR_MATCH(sample_rate, wwo->format.wf.nSamplesPerSec))
ERR("Can't set sample_rate to %lu (%d)\n",
wwo->format.wf.nSamplesPerSec, sample_rate);
@@ -1062,11 +966,10 @@
/* Remember fragsize and total buffer size for future use */
wwo->dwFragmentSize = info.fragsize;
wwo->dwBufferSize = info.fragstotal * info.fragsize;
- wwo->dwMillisPerFragment = info.fragsize * 1000 / wwo->format.wf.nAvgBytesPerSec;
wwo->uWaitForFragments = info.fragstotal * REFILL_BUFFER_WHEN;
- TRACE( "wait for %d fragments at %lu millis/fragment\n",
- wwo->uWaitForFragments,
- wwo->dwMillisPerFragment );
+ wwo->dwPlayedTotal = 0;
+ wwo->dwWrittenTotal = 0;
+ TRACE("wait for %d fragments\n", wwo->uWaitForFragments);
OSS_InitRingMessage(&wwo->msgRing);
@@ -1091,11 +994,7 @@
wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
wwo->format.wf.nBlockAlign);
- if (OSS_NotifyClient(wDevID, WOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
- WARN("can't notify client !\n");
- return MMSYSERR_INVALPARAM;
- }
- return MMSYSERR_NOERROR;
+ return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
}
/**************************************************************************
@@ -1130,10 +1029,7 @@
close(wwo->unixdev);
wwo->unixdev = -1;
wwo->dwFragmentSize = 0;
- if (OSS_NotifyClient(wDevID, WOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
- WARN("can't notify client !\n");
- ret = MMSYSERR_INVALPARAM;
- }
+ ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
}
return ret;
}
@@ -1246,10 +1142,7 @@
/* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
/* FIXME: Myst crashes with this ... hmm -MM
- if (OSS_NotifyClient(wDevID, WOM_DONE, 0L, 0L) != MMSYSERR_NOERROR) {
- WARN("can't notify client !\n");
- return MMSYSERR_INVALPARAM;
- }
+ return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
*/
return MMSYSERR_NOERROR;
@@ -1293,7 +1186,8 @@
if (lpTime == NULL) return MMSYSERR_INVALPARAM;
wwo = &WOutDev[wDevID];
- val = updatePlayedTotal(wwo);
+ OSS_AddRingMessage(&wwo->msgRing, WINE_WM_UPDATE, 0, TRUE);
+ val = wwo->dwPlayedTotal;
TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%lu nChannels=%u nAvgBytesPerSec=%lu\n",
lpTime->wType, wwo->format.wBitsPerSample,
@@ -1307,7 +1201,7 @@
TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
break;
case TIME_SAMPLES:
- lpTime->u.sample = val * 8 / wwo->format.wBitsPerSample;
+ lpTime->u.sample = val * 8 / wwo->format.wBitsPerSample /wwo->format.wf.nChannels;
TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
break;
case TIME_SMPTE:
@@ -1498,7 +1392,7 @@
* clear it, or we get junk noise */
/* some libc implementations are buggy: their memset reads from the buffer...
* to work around it, we have the 0 the block by hand and do not call:
- * memset(wwo->mapping,0,wwo->maplen);
+ * memset(wwo->mapping,0, wwo->maplen);
*/
{
char* p1 = wwo->mapping;
@@ -1902,6 +1796,31 @@
*======================================================================*/
/**************************************************************************
+ * widNotifyClient [internal]
+ */
+static DWORD widNotifyClient(WINE_WAVEIN* wwi, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
+{
+ TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
+
+ switch (wMsg) {
+ case WIM_OPEN:
+ case WIM_CLOSE:
+ case WIM_DATA:
+ if (wwi->wFlags != DCB_NULL &&
+ !DriverCallback(wwi->waveDesc.dwCallback, wwi->wFlags, wwi->waveDesc.hWave,
+ wMsg, wwi->waveDesc.dwInstance, dwParam1, dwParam2)) {
+ WARN("can't notify client !\n");
+ return MMSYSERR_ERROR;
+ }
+ break;
+ default:
+ FIXME("Unknown CB message %u\n", wMsg);
+ return MMSYSERR_INVALPARAM;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
* widGetDevCaps [internal]
*/
static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPSA lpCaps, DWORD dwSize)
@@ -1929,10 +1848,7 @@
WAVEHDR* lpWaveHdr;
DWORD dwSleepTime;
DWORD bytesRead;
- LPVOID buffer = HeapAlloc(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- wwi->dwFragmentSize);
-
+ LPVOID buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, wwi->dwFragmentSize);
LPVOID pOffset = buffer;
audio_buf_info info;
int xs;
@@ -1997,11 +1913,7 @@
lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
lpWaveHdr->dwFlags |= WHDR_DONE;
- if (OSS_NotifyClient(uDevID, WIM_DATA,
- (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR)
- {
- WARN("can't notify client !\n");
- }
+ widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
lpWaveHdr = wwi->lpQueuePtr = lpNext;
}
}
@@ -2041,11 +1953,7 @@
lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
lpWaveHdr->dwFlags |= WHDR_DONE;
- if (OSS_NotifyClient(uDevID, WIM_DATA,
- (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR)
- {
- WARN("can't notify client !\n");
- }
+ widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
wwi->lpQueuePtr = lpWaveHdr = lpNext;
if (!lpNext && bytesRead) {
@@ -2116,10 +2024,7 @@
lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
lpWaveHdr->dwFlags |= WHDR_DONE;
- if (OSS_NotifyClient(uDevID, WIM_DATA,
- (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR) {
- WARN("can't notify client !\n");
- }
+ widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
}
wwi->lpQueuePtr = NULL;
SetEvent(ev);
@@ -2258,11 +2163,7 @@
CloseHandle(wwi->hStartUpEvent);
wwi->hStartUpEvent = INVALID_HANDLE_VALUE;
- if (OSS_NotifyClient(wDevID, WIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
- WARN("can't notify client !\n");
- return MMSYSERR_INVALPARAM;
- }
- return MMSYSERR_NOERROR;
+ return widNotifyClient(wwi, WIM_OPEN, 0L, 0L);
}
/**************************************************************************
@@ -2289,11 +2190,7 @@
close(wwi->unixdev);
wwi->unixdev = -1;
wwi->dwFragmentSize = 0;
- if (OSS_NotifyClient(wDevID, WIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
- WARN("can't notify client !\n");
- return MMSYSERR_INVALPARAM;
- }
- return MMSYSERR_NOERROR;
+ return widNotifyClient(wwi, WIM_CLOSE, 0L, 0L);
}
/**************************************************************************