2 * Wine Driver for EsounD Sound Server
3 * http://www.tux.org/~ricdude/EsounD.html
5 * Copyright 1994 Martin Ayotte
6 * 1999 Eric Pouech (async playing in waveOut/waveIn)
7 * 2000 Eric Pouech (loops in waveOut)
8 * 2004 Zhangrong Huang (EsounD version of this file)
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 * with esd we cannot stop the audio that is already in
26 * the server's buffer.
29 * pause in waveOut does not work correctly in loop mode
31 * does something need to be done in for WaveIn DirectSound?
50 #ifdef HAVE_SYS_POLL_H
51 # include <sys/poll.h>
58 #include "wine/winuser16.h"
67 #include "wine/debug.h"
69 WINE_DEFAULT_DEBUG_CHANNEL(wave
);
75 /* unless someone makes a wineserver kernel module, Unix pipes are faster than win32 events */
78 /* define if you want to use esd_monitor_stream instead of
79 * esd_record_stream for waveIn stream
81 /*#define WID_USE_ESDMON*/
83 #define BUFFER_REFILL_THRESHOLD 4
85 #define MAX_WAVEOUTDRV (10)
86 #define MAX_WAVEINDRV (10)
87 #define MAX_CHANNELS 2
89 /* state diagram for waveOut writing:
91 * +---------+-------------+---------------+---------------------------------+
92 * | state | function | event | new state |
93 * +---------+-------------+---------------+---------------------------------+
94 * | | open() | | STOPPED |
95 * | PAUSED | write() | | PAUSED |
96 * | STOPPED | write() | <thrd create> | PLAYING |
97 * | PLAYING | write() | HEADER | PLAYING |
98 * | (other) | write() | <error> | |
99 * | (any) | pause() | PAUSING | PAUSED |
100 * | PAUSED | restart() | RESTARTING | PLAYING (if no thrd => STOPPED) |
101 * | (any) | reset() | RESETTING | STOPPED |
102 * | (any) | close() | CLOSING | CLOSED |
103 * +---------+-------------+---------------+---------------------------------+
106 /* states of the playing device */
107 #define WINE_WS_PLAYING 0
108 #define WINE_WS_PAUSED 1
109 #define WINE_WS_STOPPED 2
110 #define WINE_WS_CLOSED 3
112 /* events to be send to device */
113 enum win_wm_message
{
114 WINE_WM_PAUSING
= WM_USER
+ 1, WINE_WM_RESTARTING
, WINE_WM_RESETTING
, WINE_WM_HEADER
,
115 WINE_WM_UPDATE
, WINE_WM_BREAKLOOP
, WINE_WM_CLOSING
, WINE_WM_STARTING
, WINE_WM_STOPPING
119 #define SIGNAL_OMR(mr) do { int x = 0; write((mr)->msg_pipe[1], &x, sizeof(x)); } while (0)
120 #define CLEAR_OMR(mr) do { int x = 0; read((mr)->msg_pipe[0], &x, sizeof(x)); } while (0)
121 #define RESET_OMR(mr) do { } while (0)
122 #define WAIT_OMR(mr, sleep) \
123 do { struct pollfd pfd; pfd.fd = (mr)->msg_pipe[0]; \
124 pfd.events = POLLIN; poll(&pfd, 1, sleep); } while (0)
126 #define SIGNAL_OMR(mr) do { SetEvent((mr)->msg_event); } while (0)
127 #define CLEAR_OMR(mr) do { } while (0)
128 #define RESET_OMR(mr) do { ResetEvent((mr)->msg_event); } while (0)
129 #define WAIT_OMR(mr, sleep) \
130 do { WaitForSingleObject((mr)->msg_event, sleep); } while (0)
134 enum win_wm_message msg
; /* message identifier */
135 DWORD_PTR param
; /* parameter for this message */
136 HANDLE hEvent
; /* if message is synchronous, handle of event for synchro */
139 /* implement an in-process message ring for better performance
140 * (compared to passing thru the server)
141 * this ring will be used by the input (resp output) record (resp playback) routine
143 #define ESD_RING_BUFFER_INCREMENT 64
146 int ring_buffer_size
;
154 CRITICAL_SECTION msg_crst
;
158 volatile int state
; /* one of the WINE_WS_ manifest constants */
159 WAVEOPENDESC waveDesc
;
161 WAVEFORMATPCMEX waveFormat
;
163 char interface_name
[32];
165 DWORD dwSleepTime
; /* Num of milliseconds to sleep between filling the dsp buffers */
167 /* esd information */
168 int esd_fd
; /* the socket fd we get from esd when opening a stream for playing */
170 DWORD dwBufferSize
; /* size of whole buffer in bytes */
175 DWORD volume_left
; /* volume control information */
178 LPWAVEHDR lpQueuePtr
; /* start of queued WAVEHDRs (waiting to be notified) */
179 LPWAVEHDR lpPlayPtr
; /* start of not yet fully played buffers */
180 DWORD dwPartialOffset
; /* Offset of not yet written bytes in lpPlayPtr */
182 LPWAVEHDR lpLoopPtr
; /* pointer of first buffer in loop, if any */
183 DWORD dwLoops
; /* private copy of loop counter */
185 DWORD dwPlayedTotal
; /* number of bytes actually played since opening */
186 DWORD dwWrittenTotal
; /* number of bytes written to the audio device since opening */
188 /* synchronization stuff */
189 HANDLE hStartUpEvent
;
192 ESD_MSG_RING msgRing
;
196 volatile int state
; /* one of the WINE_WS_ manifest constants */
197 WAVEOPENDESC waveDesc
;
199 WAVEFORMATPCMEX waveFormat
;
201 char interface_name
[32];
203 /* esd information */
204 int esd_fd
; /* the socket fd we get from esd when opening a stream for recording */
207 LPWAVEHDR lpQueuePtr
;
208 DWORD dwRecordedTotal
;
210 /* synchronization stuff */
211 HANDLE hStartUpEvent
;
214 ESD_MSG_RING msgRing
;
217 static char* esd_host
; /* the esd host */
219 static WINE_WAVEOUT WOutDev
[MAX_WAVEOUTDRV
];
220 static WINE_WAVEIN WInDev
[MAX_WAVEINDRV
];
222 static DWORD
wodDsCreate(UINT wDevID
, PIDSDRIVER
* drv
);
223 static DWORD
wodDsDesc(UINT wDevID
, PDSDRIVERDESC desc
);
225 /* These strings used only for tracing */
226 static const char *wodPlayerCmdString
[] = {
228 "WINE_WM_RESTARTING",
238 /*======================================================================*
239 * Low level WAVE implementation *
240 *======================================================================*/
242 /* Volume functions derived from Alsaplayer source */
243 /* length is the number of 16 bit samples */
244 static void volume_effect16(void *bufin
, void* bufout
, int length
, int left
,
245 int right
, int nChannels
)
247 short *d_out
= bufout
;
252 TRACE("length == %d, nChannels == %d\n", length, nChannels);
255 if (right
== -1) right
= left
;
257 for(i
= 0; i
< length
; i
+=(nChannels
))
259 v
= (int) ((*(d_in
++) * left
) / 100);
260 *(d_out
++) = (v
>32767) ? 32767 : ((v
<-32768) ? -32768 : v
);
263 v
= (int) ((*(d_in
++) * right
) / 100);
264 *(d_out
++) = (v
>32767) ? 32767 : ((v
<-32768) ? -32768 : v
);
269 /* length is the number of 8 bit samples */
270 static void volume_effect8(void *bufin
, void* bufout
, int length
, int left
,
271 int right
, int nChannels
)
273 BYTE
*d_out
= bufout
;
278 TRACE("length == %d, nChannels == %d\n", length, nChannels);
281 if (right
== -1) right
= left
;
283 for(i
= 0; i
< length
; i
+=(nChannels
))
285 v
= (BYTE
) ((*(d_in
++) * left
) / 100);
286 *(d_out
++) = (v
>255) ? 255 : ((v
<0) ? 0 : v
);
289 v
= (BYTE
) ((*(d_in
++) * right
) / 100);
290 *(d_out
++) = (v
>255) ? 255 : ((v
<0) ? 0 : v
);
295 static DWORD
bytes_to_mmtime(LPMMTIME lpTime
, DWORD position
,
296 WAVEFORMATPCMEX
* format
)
298 TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%u nChannels=%u nAvgBytesPerSec=%u\n",
299 lpTime
->wType
, format
->Format
.wBitsPerSample
, format
->Format
.nSamplesPerSec
,
300 format
->Format
.nChannels
, format
->Format
.nAvgBytesPerSec
);
301 TRACE("Position in bytes=%u\n", position
);
303 switch (lpTime
->wType
) {
305 lpTime
->u
.sample
= position
/ (format
->Format
.wBitsPerSample
/ 8 * format
->Format
.nChannels
);
306 TRACE("TIME_SAMPLES=%u\n", lpTime
->u
.sample
);
309 lpTime
->u
.ms
= 1000.0 * position
/ (format
->Format
.wBitsPerSample
/ 8 * format
->Format
.nChannels
* format
->Format
.nSamplesPerSec
);
310 TRACE("TIME_MS=%u\n", lpTime
->u
.ms
);
313 lpTime
->u
.smpte
.fps
= 30;
314 position
= position
/ (format
->Format
.wBitsPerSample
/ 8 * format
->Format
.nChannels
);
315 position
+= (format
->Format
.nSamplesPerSec
/ lpTime
->u
.smpte
.fps
) - 1; /* round up */
316 lpTime
->u
.smpte
.sec
= position
/ format
->Format
.nSamplesPerSec
;
317 position
-= lpTime
->u
.smpte
.sec
* format
->Format
.nSamplesPerSec
;
318 lpTime
->u
.smpte
.min
= lpTime
->u
.smpte
.sec
/ 60;
319 lpTime
->u
.smpte
.sec
-= 60 * lpTime
->u
.smpte
.min
;
320 lpTime
->u
.smpte
.hour
= lpTime
->u
.smpte
.min
/ 60;
321 lpTime
->u
.smpte
.min
-= 60 * lpTime
->u
.smpte
.hour
;
322 lpTime
->u
.smpte
.fps
= 30;
323 lpTime
->u
.smpte
.frame
= position
* lpTime
->u
.smpte
.fps
/ format
->Format
.nSamplesPerSec
;
324 TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
325 lpTime
->u
.smpte
.hour
, lpTime
->u
.smpte
.min
,
326 lpTime
->u
.smpte
.sec
, lpTime
->u
.smpte
.frame
);
329 WARN("Format %d not supported, using TIME_BYTES !\n", lpTime
->wType
);
330 lpTime
->wType
= TIME_BYTES
;
333 lpTime
->u
.cb
= position
;
334 TRACE("TIME_BYTES=%u\n", lpTime
->u
.cb
);
337 return MMSYSERR_NOERROR
;
340 static BOOL
supportedFormat(LPWAVEFORMATEX wf
)
344 if (wf
->nSamplesPerSec
<DSBFREQUENCY_MIN
||wf
->nSamplesPerSec
>DSBFREQUENCY_MAX
)
347 if (wf
->wFormatTag
== WAVE_FORMAT_PCM
) {
348 if (wf
->nChannels
>= 1 && wf
->nChannels
<= MAX_CHANNELS
) {
349 if (wf
->wBitsPerSample
==8||wf
->wBitsPerSample
==16)
352 } else if (wf
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
) {
353 WAVEFORMATEXTENSIBLE
* wfex
= (WAVEFORMATEXTENSIBLE
*)wf
;
355 if (wf
->cbSize
== 22 && IsEqualGUID(&wfex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
)) {
356 if (wf
->nChannels
>=1 && wf
->nChannels
<= MAX_CHANNELS
) {
357 if (wf
->wBitsPerSample
==wfex
->Samples
.wValidBitsPerSample
) {
358 if (wf
->wBitsPerSample
==8||wf
->wBitsPerSample
==16)
361 WARN("wBitsPerSample != wValidBitsPerSample not supported yet\n");
364 WARN("only KSDATAFORMAT_SUBTYPE_PCM supported\n");
366 WARN("only WAVE_FORMAT_PCM and WAVE_FORMAT_EXTENSIBLE supported\n");
371 static void copy_format(LPWAVEFORMATEX wf1
, LPWAVEFORMATPCMEX wf2
)
373 ZeroMemory(wf2
, sizeof(wf2
));
374 if (wf1
->wFormatTag
== WAVE_FORMAT_PCM
)
375 memcpy(wf2
, wf1
, sizeof(PCMWAVEFORMAT
));
376 else if (wf1
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
377 memcpy(wf2
, wf1
, sizeof(WAVEFORMATPCMEX
));
379 memcpy(wf2
, wf1
, sizeof(WAVEFORMATEX
) + wf1
->cbSize
);
382 /******************************************************************
383 * ESD_CloseWaveOutDevice
386 static void ESD_CloseWaveOutDevice(WINE_WAVEOUT
* wwo
)
388 esd_close(wwo
->esd_fd
); /* close the esd socket fd */
391 /* free up the buffer we use for volume and reset the size */
392 HeapFree(GetProcessHeap(), 0, wwo
->sound_buffer
);
393 wwo
->sound_buffer
= NULL
;
394 wwo
->buffer_size
= 0;
397 /******************************************************************
398 * ESD_CloseWaveInDevice
401 static void ESD_CloseWaveInDevice(WINE_WAVEIN
* wwi
)
403 esd_close(wwi
->esd_fd
); /* close the esd socket fd */
407 /******************************************************************
410 LONG
ESD_WaveClose(void)
414 /* close all open devices */
415 for(iDevice
= 0; iDevice
< MAX_WAVEOUTDRV
; iDevice
++)
417 if(WOutDev
[iDevice
].esd_fd
!= -1)
419 ESD_CloseWaveOutDevice(&WOutDev
[iDevice
]);
423 for(iDevice
= 0; iDevice
< MAX_WAVEINDRV
; iDevice
++)
425 if(WInDev
[iDevice
].esd_fd
!= -1)
427 ESD_CloseWaveInDevice(&WInDev
[iDevice
]);
434 /******************************************************************
437 * Initialize internal structures from ESD server info
439 LONG
ESD_WaveInit(void)
446 /* FIXME: Maybe usefully to set the esd host. */
449 /* Testing whether the esd host is alive. */
450 if ((fd
= esd_open_sound(esd_host
)) < 0)
452 WARN("esd_open_sound() failed (%d)\n", errno
);
457 /* initialize all device handles to -1 */
458 for (i
= 0; i
< MAX_WAVEOUTDRV
; ++i
)
460 static const WCHAR ini
[] = {'E','s','o','u','n','D',' ','W','a','v','e','O','u','t','D','r','i','v','e','r',0};
462 WOutDev
[i
].esd_fd
= -1;
463 memset(&WOutDev
[i
].caps
, 0, sizeof(WOutDev
[i
].caps
)); /* zero out
465 WOutDev
[i
].caps
.wMid
= 0x00FF; /* Manufacturer ID */
466 WOutDev
[i
].caps
.wPid
= 0x0001; /* Product ID */
467 lstrcpyW(WOutDev
[i
].caps
.szPname
, ini
);
468 snprintf(WOutDev
[i
].interface_name
, sizeof(WOutDev
[i
].interface_name
), "wineesd: %d", i
);
470 WOutDev
[i
].caps
.vDriverVersion
= 0x0100;
471 WOutDev
[i
].caps
.dwFormats
= 0x00000000;
472 WOutDev
[i
].caps
.dwSupport
= WAVECAPS_VOLUME
;
474 WOutDev
[i
].caps
.wChannels
= 2;
475 WOutDev
[i
].caps
.dwSupport
|= WAVECAPS_LRVOLUME
;
477 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4M08
;
478 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4S08
;
479 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4S16
;
480 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4M16
;
481 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2M08
;
482 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2S08
;
483 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2M16
;
484 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2S16
;
485 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1M08
;
486 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1S08
;
487 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1M16
;
488 WOutDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1S16
;
491 for (i
= 0; i
< MAX_WAVEINDRV
; ++i
)
493 static const WCHAR ini
[] = {'E','s','o','u','n','D',' ','W','a','v','e','I','n','D','r','i','v','e','r',0};
495 WInDev
[i
].esd_fd
= -1;
496 memset(&WInDev
[i
].caps
, 0, sizeof(WInDev
[i
].caps
)); /* zero out
498 WInDev
[i
].caps
.wMid
= 0x00FF;
499 WInDev
[i
].caps
.wPid
= 0x0001;
500 lstrcpyW(WInDev
[i
].caps
.szPname
, ini
);
501 snprintf(WInDev
[i
].interface_name
, sizeof(WInDev
[i
].interface_name
), "wineesd: %d", i
);
503 WInDev
[i
].caps
.vDriverVersion
= 0x0100;
504 WInDev
[i
].caps
.dwFormats
= 0x00000000;
506 WInDev
[i
].caps
.wChannels
= 2;
508 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4M08
;
509 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4S08
;
510 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4S16
;
511 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_4M16
;
512 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2M08
;
513 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2S08
;
514 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2M16
;
515 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_2S16
;
516 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1M08
;
517 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1S08
;
518 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1M16
;
519 WInDev
[i
].caps
.dwFormats
|= WAVE_FORMAT_1S16
;
521 WInDev
[i
].caps
.wReserved1
= 0;
526 /******************************************************************
527 * ESD_InitRingMessage
529 * Initialize the ring of messages for passing between driver's caller and playback/record
532 static int ESD_InitRingMessage(ESD_MSG_RING
* mr
)
537 if (pipe(mr
->msg_pipe
) < 0) {
538 mr
->msg_pipe
[0] = -1;
539 mr
->msg_pipe
[1] = -1;
540 ERR("could not create pipe, error=%s\n", strerror(errno
));
543 mr
->msg_event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
545 mr
->ring_buffer_size
= ESD_RING_BUFFER_INCREMENT
;
546 mr
->messages
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,mr
->ring_buffer_size
* sizeof(RING_MSG
));
547 InitializeCriticalSection(&mr
->msg_crst
);
548 mr
->msg_crst
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": ESD_MSG_RING.msg_crst");
552 /******************************************************************
553 * ESD_DestroyRingMessage
556 static int ESD_DestroyRingMessage(ESD_MSG_RING
* mr
)
559 close(mr
->msg_pipe
[0]);
560 close(mr
->msg_pipe
[1]);
562 CloseHandle(mr
->msg_event
);
564 HeapFree(GetProcessHeap(),0,mr
->messages
);
566 mr
->msg_crst
.DebugInfo
->Spare
[0] = 0;
567 DeleteCriticalSection(&mr
->msg_crst
);
571 /******************************************************************
574 * Inserts a new message into the ring (should be called from DriverProc derived routines)
576 static int ESD_AddRingMessage(ESD_MSG_RING
* mr
, enum win_wm_message msg
, DWORD param
, BOOL wait
)
578 HANDLE hEvent
= INVALID_HANDLE_VALUE
;
580 EnterCriticalSection(&mr
->msg_crst
);
581 if ((mr
->msg_toget
== ((mr
->msg_tosave
+ 1) % mr
->ring_buffer_size
)))
583 int old_ring_buffer_size
= mr
->ring_buffer_size
;
584 mr
->ring_buffer_size
+= ESD_RING_BUFFER_INCREMENT
;
585 TRACE("mr->ring_buffer_size=%d\n",mr
->ring_buffer_size
);
586 mr
->messages
= HeapReAlloc(GetProcessHeap(),0,mr
->messages
, mr
->ring_buffer_size
* sizeof(RING_MSG
));
587 /* Now we need to rearrange the ring buffer so that the new
588 buffers just allocated are in between mr->msg_tosave and
591 if (mr
->msg_tosave
< mr
->msg_toget
)
593 memmove(&(mr
->messages
[mr
->msg_toget
+ ESD_RING_BUFFER_INCREMENT
]),
594 &(mr
->messages
[mr
->msg_toget
]),
595 sizeof(RING_MSG
)*(old_ring_buffer_size
- mr
->msg_toget
)
597 mr
->msg_toget
+= ESD_RING_BUFFER_INCREMENT
;
602 hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
603 if (hEvent
== INVALID_HANDLE_VALUE
)
605 ERR("can't create event !?\n");
606 LeaveCriticalSection(&mr
->msg_crst
);
609 if (mr
->msg_toget
!= mr
->msg_tosave
&& mr
->messages
[mr
->msg_toget
].msg
!= WINE_WM_HEADER
)
610 FIXME("two fast messages in the queue!!!!\n");
612 /* fast messages have to be added at the start of the queue */
613 mr
->msg_toget
= (mr
->msg_toget
+ mr
->ring_buffer_size
- 1) % mr
->ring_buffer_size
;
615 mr
->messages
[mr
->msg_toget
].msg
= msg
;
616 mr
->messages
[mr
->msg_toget
].param
= param
;
617 mr
->messages
[mr
->msg_toget
].hEvent
= hEvent
;
621 mr
->messages
[mr
->msg_tosave
].msg
= msg
;
622 mr
->messages
[mr
->msg_tosave
].param
= param
;
623 mr
->messages
[mr
->msg_tosave
].hEvent
= INVALID_HANDLE_VALUE
;
624 mr
->msg_tosave
= (mr
->msg_tosave
+ 1) % mr
->ring_buffer_size
;
627 LeaveCriticalSection(&mr
->msg_crst
);
629 /* signal a new message */
633 /* wait for playback/record thread to have processed the message */
634 WaitForSingleObject(hEvent
, INFINITE
);
641 /******************************************************************
642 * ESD_RetrieveRingMessage
644 * Get a message from the ring. Should be called by the playback/record thread.
646 static int ESD_RetrieveRingMessage(ESD_MSG_RING
* mr
, enum win_wm_message
*msg
,
647 DWORD_PTR
*param
, HANDLE
*hEvent
)
649 EnterCriticalSection(&mr
->msg_crst
);
651 if (mr
->msg_toget
== mr
->msg_tosave
) /* buffer empty ? */
653 LeaveCriticalSection(&mr
->msg_crst
);
657 *msg
= mr
->messages
[mr
->msg_toget
].msg
;
658 mr
->messages
[mr
->msg_toget
].msg
= 0;
659 *param
= mr
->messages
[mr
->msg_toget
].param
;
660 *hEvent
= mr
->messages
[mr
->msg_toget
].hEvent
;
661 mr
->msg_toget
= (mr
->msg_toget
+ 1) % mr
->ring_buffer_size
;
663 LeaveCriticalSection(&mr
->msg_crst
);
667 /*======================================================================*
668 * Low level WAVE OUT implementation *
669 *======================================================================*/
671 /**************************************************************************
672 * wodNotifyClient [internal]
674 static DWORD
wodNotifyClient(WINE_WAVEOUT
* wwo
, WORD wMsg
, DWORD_PTR dwParam1
,
677 TRACE("wMsg = 0x%04x dwParm1 = %08lX dwParam2 = %08lX\n", wMsg
, dwParam1
, dwParam2
);
683 if (wwo
->wFlags
!= DCB_NULL
&&
684 !DriverCallback(wwo
->waveDesc
.dwCallback
, wwo
->wFlags
, (HDRVR
)wwo
->waveDesc
.hWave
,
685 wMsg
, wwo
->waveDesc
.dwInstance
, dwParam1
, dwParam2
)) {
686 WARN("can't notify client !\n");
687 return MMSYSERR_ERROR
;
691 FIXME("Unknown callback message %u\n", wMsg
);
692 return MMSYSERR_INVALPARAM
;
694 return MMSYSERR_NOERROR
;
697 /**************************************************************************
698 * wodUpdatePlayedTotal [internal]
701 static BOOL
wodUpdatePlayedTotal(WINE_WAVEOUT
* wwo
)
703 /* total played is the bytes written less the bytes to write ;-) */
704 wwo
->dwPlayedTotal
= wwo
->dwWrittenTotal
;
709 /**************************************************************************
710 * wodPlayer_BeginWaveHdr [internal]
712 * Makes the specified lpWaveHdr the currently playing wave header.
713 * If the specified wave header is a begin loop and we're not already in
714 * a loop, setup the loop.
716 static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT
* wwo
, LPWAVEHDR lpWaveHdr
)
718 wwo
->lpPlayPtr
= lpWaveHdr
;
720 if (!lpWaveHdr
) return;
722 if (lpWaveHdr
->dwFlags
& WHDR_BEGINLOOP
) {
723 if (wwo
->lpLoopPtr
) {
724 WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr
);
725 TRACE("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr
);
727 TRACE("Starting loop (%dx) with %p\n", lpWaveHdr
->dwLoops
, lpWaveHdr
);
728 wwo
->lpLoopPtr
= lpWaveHdr
;
729 /* Windows does not touch WAVEHDR.dwLoops,
730 * so we need to make an internal copy */
731 wwo
->dwLoops
= lpWaveHdr
->dwLoops
;
734 wwo
->dwPartialOffset
= 0;
737 /**************************************************************************
738 * wodPlayer_PlayPtrNext [internal]
740 * Advance the play pointer to the next waveheader, looping if required.
742 static LPWAVEHDR
wodPlayer_PlayPtrNext(WINE_WAVEOUT
* wwo
)
744 LPWAVEHDR lpWaveHdr
= wwo
->lpPlayPtr
;
746 wwo
->dwPartialOffset
= 0;
747 if ((lpWaveHdr
->dwFlags
& WHDR_ENDLOOP
) && wwo
->lpLoopPtr
) {
748 /* We're at the end of a loop, loop if required */
749 if (--wwo
->dwLoops
> 0) {
750 wwo
->lpPlayPtr
= wwo
->lpLoopPtr
;
752 /* Handle overlapping loops correctly */
753 if (wwo
->lpLoopPtr
!= lpWaveHdr
&& (lpWaveHdr
->dwFlags
& WHDR_BEGINLOOP
)) {
754 FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
755 /* shall we consider the END flag for the closing loop or for
756 * the opening one or for both ???
757 * code assumes for closing loop only
760 lpWaveHdr
= lpWaveHdr
->lpNext
;
762 wwo
->lpLoopPtr
= NULL
;
763 wodPlayer_BeginWaveHdr(wwo
, lpWaveHdr
);
766 /* We're not in a loop. Advance to the next wave header */
767 wodPlayer_BeginWaveHdr(wwo
, lpWaveHdr
= lpWaveHdr
->lpNext
);
773 /**************************************************************************
774 * wodPlayer_NotifyWait [internal]
775 * Returns the number of milliseconds to wait before attempting to notify
776 * completion of the specified wavehdr.
777 * This is based on the number of bytes remaining to be written in the
780 static DWORD
wodPlayer_NotifyWait(const WINE_WAVEOUT
* wwo
, LPWAVEHDR lpWaveHdr
)
784 if(lpWaveHdr
->reserved
< wwo
->dwPlayedTotal
)
790 dwMillis
= (lpWaveHdr
->reserved
- wwo
->dwPlayedTotal
) * 1000 / wwo
->waveFormat
.Format
.nAvgBytesPerSec
;
791 if(!dwMillis
) dwMillis
= 1;
794 TRACE("dwMillis = %d\n", dwMillis
);
800 /**************************************************************************
801 * wodPlayer_WriteMaxFrags [internal]
802 * Writes the maximum number of bytes possible to the DSP and returns
803 * the number of bytes written.
805 static int wodPlayer_WriteMaxFrags(WINE_WAVEOUT
* wwo
, DWORD
* bytes
)
807 /* Only attempt to write to free bytes */
808 DWORD dwLength
= wwo
->lpPlayPtr
->dwBufferLength
- wwo
->dwPartialOffset
;
809 int toWrite
= min(dwLength
, *bytes
);
812 TRACE("Writing wavehdr %p.%u[%u]\n",
813 wwo
->lpPlayPtr
, wwo
->dwPartialOffset
, wwo
->lpPlayPtr
->dwBufferLength
);
815 /* see if our buffer isn't large enough for the data we are writing */
816 if(wwo
->buffer_size
< toWrite
)
818 if(wwo
->sound_buffer
)
820 wwo
->sound_buffer
= HeapReAlloc(GetProcessHeap(), 0, wwo
->sound_buffer
, toWrite
);
821 wwo
->buffer_size
= toWrite
;
825 /* if we don't have a buffer then get one */
826 if(!wwo
->sound_buffer
)
828 /* allocate some memory for the buffer */
829 wwo
->sound_buffer
= HeapAlloc(GetProcessHeap(), 0, toWrite
);
830 wwo
->buffer_size
= toWrite
;
833 /* if we don't have a buffer then error out */
834 if(!wwo
->sound_buffer
)
836 ERR("error allocating sound_buffer memory\n");
840 TRACE("toWrite == %d\n", toWrite
);
842 /* apply volume to the bits */
843 /* for single channel audio streams we only use the LEFT volume */
844 if(wwo
->waveFormat
.Format
.wBitsPerSample
== 16)
846 /* apply volume to the buffer we are about to send */
847 /* divide toWrite(bytes) by 2 as volume processes by 16 bits */
848 volume_effect16(wwo
->lpPlayPtr
->lpData
+ wwo
->dwPartialOffset
,
849 wwo
->sound_buffer
, toWrite
>>1, wwo
->volume_left
,
850 wwo
->volume_right
, wwo
->waveFormat
.Format
.nChannels
);
851 } else if(wwo
->waveFormat
.Format
.wBitsPerSample
== 8)
853 /* apply volume to the buffer we are about to send */
854 volume_effect8(wwo
->lpPlayPtr
->lpData
+ wwo
->dwPartialOffset
,
855 wwo
->sound_buffer
, toWrite
, wwo
->volume_left
,
856 wwo
->volume_right
, wwo
->waveFormat
.Format
.nChannels
);
859 FIXME("unsupported wwo->format.wBitsPerSample of %d\n",
860 wwo
->waveFormat
.Format
.wBitsPerSample
);
863 /* send the audio data to esd for playing */
864 written
= write(wwo
->esd_fd
, wwo
->sound_buffer
, toWrite
);
866 TRACE("written = %d\n", written
);
870 *bytes
= 0; /* apparently esd is actually full */
871 return written
; /* if we wrote nothing just return */
874 if (written
>= dwLength
)
875 wodPlayer_PlayPtrNext(wwo
); /* If we wrote all current wavehdr, skip to the next one */
877 wwo
->dwPartialOffset
+= written
; /* Remove the amount written */
879 if (written
< toWrite
)
884 wwo
->dwWrittenTotal
+= written
; /* update stats on this wave device */
886 return written
; /* return the number of bytes written */
890 /**************************************************************************
891 * wodPlayer_NotifyCompletions [internal]
893 * Notifies and remove from queue all wavehdrs which have been played to
894 * the speaker (ie. they have cleared the audio device). If force is true,
895 * we notify all wavehdrs and remove them all from the queue even if they
896 * are unplayed or part of a loop.
898 static DWORD
wodPlayer_NotifyCompletions(WINE_WAVEOUT
* wwo
, BOOL force
)
902 if (wwo
->lpQueuePtr
) {
903 TRACE("lpWaveHdr=(%p), lpPlayPtr=(%p), lpLoopPtr=(%p), reserved=(%ld), dwWrittenTotal=(%d), force=(%d)\n",
907 wwo
->lpQueuePtr
->reserved
,
911 TRACE("lpWaveHdr=(%p), lpPlayPtr=(%p), lpLoopPtr=(%p), dwWrittenTotal=(%d), force=(%d)\n",
919 /* Start from lpQueuePtr and keep notifying until:
920 * - we hit an unwritten wavehdr
921 * - we hit the beginning of a running loop
922 * - we hit a wavehdr which hasn't finished playing
924 while ((lpWaveHdr
= wwo
->lpQueuePtr
) &&
926 (lpWaveHdr
!= wwo
->lpPlayPtr
&&
927 lpWaveHdr
!= wwo
->lpLoopPtr
&&
928 lpWaveHdr
->reserved
<= wwo
->dwWrittenTotal
))) {
930 wwo
->lpQueuePtr
= lpWaveHdr
->lpNext
;
932 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
933 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
935 wodNotifyClient(wwo
, WOM_DONE
, (DWORD_PTR
)lpWaveHdr
, 0);
937 return (lpWaveHdr
&& lpWaveHdr
!= wwo
->lpPlayPtr
&& lpWaveHdr
!= wwo
->lpLoopPtr
) ?
938 wodPlayer_NotifyWait(wwo
, lpWaveHdr
) : INFINITE
;
941 /**************************************************************************
942 * wodPlayer_Reset [internal]
944 * wodPlayer helper. Resets current output stream.
946 static void wodPlayer_Reset(WINE_WAVEOUT
* wwo
, BOOL reset
)
948 wodUpdatePlayedTotal(wwo
);
950 wodPlayer_NotifyCompletions(wwo
, FALSE
); /* updates current notify list */
952 /* we aren't able to flush any data that has already been written */
953 /* to esd, otherwise we would do the flushing here */
956 enum win_wm_message msg
;
960 /* remove any buffer */
961 wodPlayer_NotifyCompletions(wwo
, TRUE
);
963 wwo
->lpPlayPtr
= wwo
->lpQueuePtr
= wwo
->lpLoopPtr
= NULL
;
964 wwo
->state
= WINE_WS_STOPPED
;
965 wwo
->dwPlayedTotal
= wwo
->dwWrittenTotal
= 0;
967 wwo
->dwPartialOffset
= 0; /* Clear partial wavehdr */
969 /* remove any existing message in the ring */
970 EnterCriticalSection(&wwo
->msgRing
.msg_crst
);
972 /* return all pending headers in queue */
973 while (ESD_RetrieveRingMessage(&wwo
->msgRing
, &msg
, ¶m
, &ev
))
975 TRACE("flushing msg\n");
976 if (msg
!= WINE_WM_HEADER
)
978 FIXME("shouldn't have headers left\n");
982 ((LPWAVEHDR
)param
)->dwFlags
&= ~WHDR_INQUEUE
;
983 ((LPWAVEHDR
)param
)->dwFlags
|= WHDR_DONE
;
985 wodNotifyClient(wwo
, WOM_DONE
, param
, 0);
987 RESET_OMR(&wwo
->msgRing
);
988 LeaveCriticalSection(&wwo
->msgRing
.msg_crst
);
990 if (wwo
->lpLoopPtr
) {
991 /* complicated case, not handled yet (could imply modifying the loop counter */
992 FIXME("Pausing while in loop isn't correctly handled yet, except strange results\n");
993 wwo
->lpPlayPtr
= wwo
->lpLoopPtr
;
994 wwo
->dwPartialOffset
= 0;
995 wwo
->dwWrittenTotal
= wwo
->dwPlayedTotal
; /* this is wrong !!! */
997 /* the data already written is going to be played, so take */
998 /* this fact into account here */
999 wwo
->dwPlayedTotal
= wwo
->dwWrittenTotal
;
1001 wwo
->state
= WINE_WS_PAUSED
;
1005 /**************************************************************************
1006 * wodPlayer_ProcessMessages [internal]
1008 static void wodPlayer_ProcessMessages(WINE_WAVEOUT
* wwo
)
1010 LPWAVEHDR lpWaveHdr
;
1011 enum win_wm_message msg
;
1015 while (ESD_RetrieveRingMessage(&wwo
->msgRing
, &msg
, ¶m
, &ev
)) {
1016 TRACE("Received %s %lx\n", wodPlayerCmdString
[msg
- WM_USER
- 1], param
);
1018 case WINE_WM_PAUSING
:
1019 wodPlayer_Reset(wwo
, FALSE
);
1022 case WINE_WM_RESTARTING
:
1023 wwo
->state
= WINE_WS_PLAYING
;
1026 case WINE_WM_HEADER
:
1027 lpWaveHdr
= (LPWAVEHDR
)param
;
1029 /* insert buffer at the end of queue */
1032 for (wh
= &(wwo
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
1035 if (!wwo
->lpPlayPtr
)
1036 wodPlayer_BeginWaveHdr(wwo
,lpWaveHdr
);
1037 if (wwo
->state
== WINE_WS_STOPPED
)
1038 wwo
->state
= WINE_WS_PLAYING
;
1040 case WINE_WM_RESETTING
:
1041 wodPlayer_Reset(wwo
, TRUE
);
1044 case WINE_WM_UPDATE
:
1045 wodUpdatePlayedTotal(wwo
);
1048 case WINE_WM_BREAKLOOP
:
1049 if (wwo
->state
== WINE_WS_PLAYING
&& wwo
->lpLoopPtr
!= NULL
) {
1050 /* ensure exit at end of current loop */
1055 case WINE_WM_CLOSING
:
1056 /* sanity check: this should not happen since the device must have been reset before */
1057 if (wwo
->lpQueuePtr
|| wwo
->lpPlayPtr
) ERR("out of sync\n");
1059 wwo
->state
= WINE_WS_CLOSED
;
1062 /* shouldn't go here */
1064 FIXME("unknown message %d\n", msg
);
1070 /**************************************************************************
1071 * wodPlayer_FeedDSP [internal]
1072 * Feed as much sound data as we can into the DSP and return the number of
1073 * milliseconds before it will be necessary to feed the DSP again.
1075 static DWORD
wodPlayer_FeedDSP(WINE_WAVEOUT
* wwo
)
1079 wodUpdatePlayedTotal(wwo
);
1080 /* better way to set availInQ? */
1081 availInQ
= ESD_BUF_SIZE
;
1082 TRACE("availInQ = %d\n", availInQ
);
1084 /* input queue empty */
1085 if (!wwo
->lpPlayPtr
) {
1086 TRACE("Run out of wavehdr:s... flushing\n");
1091 /* no more room... no need to try to feed */
1094 TRACE("no more room, no need to try to feed\n");
1095 return wwo
->dwSleepTime
;
1099 /* Feed from partial wavehdr */
1100 if (wwo
->lpPlayPtr
&& wwo
->dwPartialOffset
!= 0)
1102 TRACE("feeding from partial wavehdr\n");
1103 wodPlayer_WriteMaxFrags(wwo
, &availInQ
);
1106 /* Feed wavehdrs until we run out of wavehdrs or DSP space */
1107 if (!wwo
->dwPartialOffset
)
1109 while(wwo
->lpPlayPtr
&& availInQ
)
1111 TRACE("feeding waveheaders until we run out of space\n");
1112 /* note the value that dwPlayedTotal will return when this wave finishes playing */
1113 wwo
->lpPlayPtr
->reserved
= wwo
->dwWrittenTotal
+ wwo
->lpPlayPtr
->dwBufferLength
;
1114 TRACE("reserved=(%ld) dwWrittenTotal=(%d) dwBufferLength=(%d)\n",
1115 wwo
->lpPlayPtr
->reserved
,
1116 wwo
->dwWrittenTotal
,
1117 wwo
->lpPlayPtr
->dwBufferLength
1119 wodPlayer_WriteMaxFrags(wwo
, &availInQ
);
1123 if (!wwo
->lpPlayPtr
) {
1124 TRACE("Ran out of wavehdrs\n");
1128 return wwo
->dwSleepTime
;
1132 /**************************************************************************
1133 * wodPlayer [internal]
1135 static DWORD CALLBACK
wodPlayer(LPVOID pmt
)
1137 WORD uDevID
= (DWORD_PTR
)pmt
;
1138 WINE_WAVEOUT
* wwo
= &WOutDev
[uDevID
];
1139 DWORD dwNextFeedTime
= INFINITE
; /* Time before DSP needs feeding */
1140 DWORD dwNextNotifyTime
= INFINITE
; /* Time before next wave completion */
1143 wwo
->state
= WINE_WS_STOPPED
;
1144 SetEvent(wwo
->hStartUpEvent
);
1147 /** Wait for the shortest time before an action is required. If there
1148 * are no pending actions, wait forever for a command.
1150 dwSleepTime
= min(dwNextFeedTime
, dwNextNotifyTime
);
1151 TRACE("waiting %ums (%u,%u)\n", dwSleepTime
, dwNextFeedTime
, dwNextNotifyTime
);
1152 WAIT_OMR(&wwo
->msgRing
, dwSleepTime
);
1153 wodPlayer_ProcessMessages(wwo
);
1154 if (wwo
->state
== WINE_WS_PLAYING
) {
1155 dwNextFeedTime
= wodPlayer_FeedDSP(wwo
);
1156 dwNextNotifyTime
= wodPlayer_NotifyCompletions(wwo
, FALSE
);
1158 dwNextFeedTime
= dwNextNotifyTime
= INFINITE
;
1165 /**************************************************************************
1166 * wodGetDevCaps [internal]
1168 static DWORD
wodGetDevCaps(WORD wDevID
, LPWAVEOUTCAPSW lpCaps
, DWORD dwSize
)
1170 TRACE("(%u, %p, %u);\n", wDevID
, lpCaps
, dwSize
);
1172 if (lpCaps
== NULL
) return MMSYSERR_NOTENABLED
;
1174 if (wDevID
>= MAX_WAVEOUTDRV
) {
1175 TRACE("MAX_WAVOUTDRV reached !\n");
1176 return MMSYSERR_BADDEVICEID
;
1179 memcpy(lpCaps
, &WOutDev
[wDevID
].caps
, min(dwSize
, sizeof(*lpCaps
)));
1180 return MMSYSERR_NOERROR
;
1183 /**************************************************************************
1184 * wodOpen [internal]
1186 static DWORD
wodOpen(WORD wDevID
, LPWAVEOPENDESC lpDesc
, DWORD dwFlags
)
1189 /* output to esound... */
1190 int out_bits
= ESD_BITS8
, out_channels
= ESD_MONO
, out_rate
;
1191 int out_mode
= ESD_STREAM
, out_func
= ESD_PLAY
;
1192 esd_format_t out_format
;
1194 TRACE("(%u, %p, %08X);\n", wDevID
, lpDesc
, dwFlags
);
1195 if (lpDesc
== NULL
) {
1196 WARN("Invalid Parameter !\n");
1197 return MMSYSERR_INVALPARAM
;
1199 if (wDevID
>= MAX_WAVEOUTDRV
) {
1200 TRACE("MAX_WAVOUTDRV reached !\n");
1201 return MMSYSERR_BADDEVICEID
;
1204 /* if this device is already open tell the app that it is allocated */
1205 if(WOutDev
[wDevID
].esd_fd
!= -1)
1207 TRACE("device already allocated\n");
1208 return MMSYSERR_ALLOCATED
;
1211 /* only PCM format is supported so far... */
1212 if (!supportedFormat(lpDesc
->lpFormat
)) {
1213 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1214 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
1215 lpDesc
->lpFormat
->nSamplesPerSec
);
1216 return WAVERR_BADFORMAT
;
1219 if (dwFlags
& WAVE_FORMAT_QUERY
) {
1220 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1221 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
1222 lpDesc
->lpFormat
->nSamplesPerSec
);
1223 return MMSYSERR_NOERROR
;
1226 wwo
= &WOutDev
[wDevID
];
1228 /* direct sound not supported, ignore the flag */
1229 dwFlags
&= ~WAVE_DIRECTSOUND
;
1231 wwo
->wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
1233 wwo
->waveDesc
= *lpDesc
;
1234 copy_format(lpDesc
->lpFormat
, &wwo
->waveFormat
);
1236 if (wwo
->waveFormat
.Format
.wBitsPerSample
== 0) {
1237 WARN("Resetting zeroed wBitsPerSample\n");
1238 wwo
->waveFormat
.Format
.wBitsPerSample
= 8 *
1239 (wwo
->waveFormat
.Format
.nAvgBytesPerSec
/
1240 wwo
->waveFormat
.Format
.nSamplesPerSec
) /
1241 wwo
->waveFormat
.Format
.nChannels
;
1244 if (wwo
->waveFormat
.Format
.wBitsPerSample
== 8)
1245 out_bits
= ESD_BITS8
;
1246 else if (wwo
->waveFormat
.Format
.wBitsPerSample
== 16)
1247 out_bits
= ESD_BITS16
;
1249 wwo
->bytes_per_frame
= (wwo
->waveFormat
.Format
.wBitsPerSample
* wwo
->waveFormat
.Format
.nChannels
) / 8;
1251 if (wwo
->waveFormat
.Format
.nChannels
== 1)
1252 out_channels
= ESD_MONO
;
1253 else if (wwo
->waveFormat
.Format
.nChannels
== 2)
1254 out_channels
= ESD_STEREO
;
1256 out_format
= out_bits
| out_channels
| out_mode
| out_func
;
1257 out_rate
= (int) wwo
->waveFormat
.Format
.nSamplesPerSec
;
1258 TRACE("esd output format = 0x%08x, rate = %d\n", out_format
, out_rate
);
1260 wwo
->esd_fd
= esd_play_stream(out_format
, out_rate
, esd_host
, "wineesd");
1262 /* clear these so we don't have any confusion ;-) */
1263 wwo
->sound_buffer
= 0;
1264 wwo
->buffer_size
= 0;
1266 if(wwo
->esd_fd
< 0) return MMSYSERR_ALLOCATED
;
1268 wwo
->dwBufferSize
= ESD_BUF_SIZE
;
1269 TRACE("Buffer size is now (%d)\n",wwo
->dwBufferSize
);
1271 wwo
->dwPlayedTotal
= 0;
1272 wwo
->dwWrittenTotal
= 0;
1274 wwo
->dwSleepTime
= (1024 * 1000 * BUFFER_REFILL_THRESHOLD
) / wwo
->waveFormat
.Format
.nAvgBytesPerSec
;
1276 /* Initialize volume to full level */
1277 wwo
->volume_left
= 100;
1278 wwo
->volume_right
= 100;
1280 ESD_InitRingMessage(&wwo
->msgRing
);
1282 /* create player thread */
1283 if (!(dwFlags
& WAVE_DIRECTSOUND
)) {
1284 wwo
->hStartUpEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1285 wwo
->hThread
= CreateThread(NULL
, 0, wodPlayer
, (LPVOID
)(DWORD_PTR
)wDevID
,
1286 0, &(wwo
->dwThreadID
));
1287 WaitForSingleObject(wwo
->hStartUpEvent
, INFINITE
);
1288 CloseHandle(wwo
->hStartUpEvent
);
1290 wwo
->hThread
= INVALID_HANDLE_VALUE
;
1291 wwo
->dwThreadID
= 0;
1293 wwo
->hStartUpEvent
= INVALID_HANDLE_VALUE
;
1295 TRACE("esd=0x%lx, dwBufferSize=%d\n",
1296 (long)wwo
->esd_fd
, wwo
->dwBufferSize
);
1298 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
1299 wwo
->waveFormat
.Format
.wBitsPerSample
, wwo
->waveFormat
.Format
.nAvgBytesPerSec
,
1300 wwo
->waveFormat
.Format
.nSamplesPerSec
, wwo
->waveFormat
.Format
.nChannels
,
1301 wwo
->waveFormat
.Format
.nBlockAlign
);
1303 return wodNotifyClient(wwo
, WOM_OPEN
, 0L, 0L);
1306 /**************************************************************************
1307 * wodClose [internal]
1309 static DWORD
wodClose(WORD wDevID
)
1311 DWORD ret
= MMSYSERR_NOERROR
;
1314 TRACE("(%u);\n", wDevID
);
1316 if (wDevID
>= MAX_WAVEOUTDRV
|| WOutDev
[wDevID
].esd_fd
== -1) {
1317 WARN("bad device ID !\n");
1318 return MMSYSERR_BADDEVICEID
;
1321 wwo
= &WOutDev
[wDevID
];
1322 if (wwo
->lpQueuePtr
) {
1323 WARN("buffers still playing !\n");
1324 ret
= WAVERR_STILLPLAYING
;
1326 TRACE("imhere[3-close]\n");
1327 if (wwo
->hThread
!= INVALID_HANDLE_VALUE
) {
1328 ESD_AddRingMessage(&wwo
->msgRing
, WINE_WM_CLOSING
, 0, TRUE
);
1331 ESD_DestroyRingMessage(&wwo
->msgRing
);
1333 ESD_CloseWaveOutDevice(wwo
); /* close the stream and clean things up */
1335 ret
= wodNotifyClient(wwo
, WOM_CLOSE
, 0L, 0L);
1340 /**************************************************************************
1341 * wodWrite [internal]
1344 static DWORD
wodWrite(WORD wDevID
, LPWAVEHDR lpWaveHdr
, DWORD dwSize
)
1346 TRACE("(%u, %p, %08X);\n", wDevID
, lpWaveHdr
, dwSize
);
1348 /* first, do the sanity checks... */
1349 if (wDevID
>= MAX_WAVEOUTDRV
|| WOutDev
[wDevID
].esd_fd
== -1) {
1350 WARN("bad dev ID !\n");
1351 return MMSYSERR_BADDEVICEID
;
1354 if (lpWaveHdr
->lpData
== NULL
|| !(lpWaveHdr
->dwFlags
& WHDR_PREPARED
))
1356 TRACE("unprepared\n");
1357 return WAVERR_UNPREPARED
;
1360 if (lpWaveHdr
->dwFlags
& WHDR_INQUEUE
)
1362 TRACE("still playing\n");
1363 return WAVERR_STILLPLAYING
;
1366 lpWaveHdr
->dwFlags
&= ~WHDR_DONE
;
1367 lpWaveHdr
->dwFlags
|= WHDR_INQUEUE
;
1368 lpWaveHdr
->lpNext
= 0;
1370 TRACE("adding ring message\n");
1371 ESD_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_HEADER
,
1372 (DWORD_PTR
)lpWaveHdr
, FALSE
);
1374 return MMSYSERR_NOERROR
;
1377 /**************************************************************************
1378 * wodPause [internal]
1380 static DWORD
wodPause(WORD wDevID
)
1382 TRACE("(%u);!\n", wDevID
);
1384 if (wDevID
>= MAX_WAVEOUTDRV
|| WOutDev
[wDevID
].esd_fd
== -1) {
1385 WARN("bad device ID !\n");
1386 return MMSYSERR_BADDEVICEID
;
1389 TRACE("imhere[3-PAUSING]\n");
1390 ESD_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_PAUSING
, 0, TRUE
);
1392 return MMSYSERR_NOERROR
;
1395 /**************************************************************************
1396 * wodRestart [internal]
1398 static DWORD
wodRestart(WORD wDevID
)
1400 TRACE("(%u);\n", wDevID
);
1402 if (wDevID
>= MAX_WAVEOUTDRV
|| WOutDev
[wDevID
].esd_fd
== -1) {
1403 WARN("bad device ID !\n");
1404 return MMSYSERR_BADDEVICEID
;
1407 if (WOutDev
[wDevID
].state
== WINE_WS_PAUSED
) {
1408 TRACE("imhere[3-RESTARTING]\n");
1409 ESD_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_RESTARTING
, 0, TRUE
);
1412 /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
1413 /* FIXME: Myst crashes with this ... hmm -MM
1414 return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
1417 return MMSYSERR_NOERROR
;
1420 /**************************************************************************
1421 * wodReset [internal]
1423 static DWORD
wodReset(WORD wDevID
)
1425 TRACE("(%u);\n", wDevID
);
1427 if (wDevID
>= MAX_WAVEOUTDRV
|| WOutDev
[wDevID
].esd_fd
== -1) {
1428 WARN("bad device ID !\n");
1429 return MMSYSERR_BADDEVICEID
;
1432 TRACE("imhere[3-RESET]\n");
1433 ESD_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_RESETTING
, 0, TRUE
);
1435 return MMSYSERR_NOERROR
;
1438 /**************************************************************************
1439 * wodGetPosition [internal]
1441 static DWORD
wodGetPosition(WORD wDevID
, LPMMTIME lpTime
, DWORD uSize
)
1445 TRACE("(%u, %p, %u);\n", wDevID
, lpTime
, uSize
);
1447 if (wDevID
>= MAX_WAVEOUTDRV
|| WOutDev
[wDevID
].esd_fd
== -1) {
1448 WARN("bad device ID !\n");
1449 return MMSYSERR_BADDEVICEID
;
1452 if (lpTime
== NULL
) {
1453 WARN("invalid parameter: lpTime == NULL\n");
1454 return MMSYSERR_INVALPARAM
;
1457 wwo
= &WOutDev
[wDevID
];
1458 ESD_AddRingMessage(&wwo
->msgRing
, WINE_WM_UPDATE
, 0, TRUE
);
1460 return bytes_to_mmtime(lpTime
, wwo
->dwPlayedTotal
, &wwo
->waveFormat
);
1463 /**************************************************************************
1464 * wodBreakLoop [internal]
1466 static DWORD
wodBreakLoop(WORD wDevID
)
1468 TRACE("(%u);\n", wDevID
);
1470 if (wDevID
>= MAX_WAVEOUTDRV
|| WOutDev
[wDevID
].esd_fd
== -1) {
1471 WARN("bad device ID !\n");
1472 return MMSYSERR_BADDEVICEID
;
1474 ESD_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_BREAKLOOP
, 0, TRUE
);
1475 return MMSYSERR_NOERROR
;
1478 /**************************************************************************
1479 * wodGetVolume [internal]
1481 static DWORD
wodGetVolume(WORD wDevID
, LPDWORD lpdwVol
)
1485 left
= WOutDev
[wDevID
].volume_left
;
1486 right
= WOutDev
[wDevID
].volume_right
;
1488 TRACE("(%u, %p);\n", wDevID
, lpdwVol
);
1490 *lpdwVol
= ((left
* 0xFFFFl
) / 100) + (((right
* 0xFFFFl
) / 100) <<
1493 return MMSYSERR_NOERROR
;
1496 /**************************************************************************
1497 * wodSetVolume [internal]
1499 static DWORD
wodSetVolume(WORD wDevID
, DWORD dwParam
)
1503 left
= (LOWORD(dwParam
) * 100) / 0xFFFFl
;
1504 right
= (HIWORD(dwParam
) * 100) / 0xFFFFl
;
1506 TRACE("(%u, %08X);\n", wDevID
, dwParam
);
1508 WOutDev
[wDevID
].volume_left
= left
;
1509 WOutDev
[wDevID
].volume_right
= right
;
1511 return MMSYSERR_NOERROR
;
1514 /**************************************************************************
1515 * wodGetNumDevs [internal]
1517 static DWORD
wodGetNumDevs(void)
1519 return MAX_WAVEOUTDRV
;
1522 /**************************************************************************
1523 * wodDevInterfaceSize [internal]
1525 static DWORD
wodDevInterfaceSize(UINT wDevID
, LPDWORD dwParam1
)
1527 TRACE("(%u, %p)\n", wDevID
, dwParam1
);
1529 *dwParam1
= MultiByteToWideChar(CP_ACP
, 0, WOutDev
[wDevID
].interface_name
, -1,
1530 NULL
, 0 ) * sizeof(WCHAR
);
1531 return MMSYSERR_NOERROR
;
1534 /**************************************************************************
1535 * wodDevInterface [internal]
1537 static DWORD
wodDevInterface(UINT wDevID
, PWCHAR dwParam1
, DWORD dwParam2
)
1539 if (dwParam2
>= MultiByteToWideChar(CP_ACP
, 0, WOutDev
[wDevID
].interface_name
, -1,
1540 NULL
, 0 ) * sizeof(WCHAR
))
1542 MultiByteToWideChar(CP_ACP
, 0, WOutDev
[wDevID
].interface_name
, -1,
1543 dwParam1
, dwParam2
/ sizeof(WCHAR
));
1544 return MMSYSERR_NOERROR
;
1546 return MMSYSERR_INVALPARAM
;
1549 /**************************************************************************
1550 * wodMessage (WINEESD.@)
1552 DWORD WINAPI
ESD_wodMessage(UINT wDevID
, UINT wMsg
, DWORD dwUser
,
1553 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1555 TRACE("(%u, %04X, %08X, %08lX, %08lX);\n",
1556 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1563 /* FIXME: Pretend this is supported */
1565 case WODM_OPEN
: return wodOpen (wDevID
, (LPWAVEOPENDESC
)dwParam1
, dwParam2
);
1566 case WODM_CLOSE
: return wodClose (wDevID
);
1567 case WODM_WRITE
: return wodWrite (wDevID
, (LPWAVEHDR
)dwParam1
, dwParam2
);
1568 case WODM_PAUSE
: return wodPause (wDevID
);
1569 case WODM_GETPOS
: return wodGetPosition (wDevID
, (LPMMTIME
)dwParam1
, dwParam2
);
1570 case WODM_BREAKLOOP
: return wodBreakLoop (wDevID
);
1571 case WODM_PREPARE
: return MMSYSERR_NOTSUPPORTED
;
1572 case WODM_UNPREPARE
: return MMSYSERR_NOTSUPPORTED
;
1573 case WODM_GETDEVCAPS
: return wodGetDevCaps (wDevID
, (LPWAVEOUTCAPSW
)dwParam1
, dwParam2
);
1574 case WODM_GETNUMDEVS
: return wodGetNumDevs ();
1575 case WODM_GETPITCH
: return MMSYSERR_NOTSUPPORTED
;
1576 case WODM_SETPITCH
: return MMSYSERR_NOTSUPPORTED
;
1577 case WODM_GETPLAYBACKRATE
: return MMSYSERR_NOTSUPPORTED
;
1578 case WODM_SETPLAYBACKRATE
: return MMSYSERR_NOTSUPPORTED
;
1579 case WODM_GETVOLUME
: return wodGetVolume (wDevID
, (LPDWORD
)dwParam1
);
1580 case WODM_SETVOLUME
: return wodSetVolume (wDevID
, dwParam1
);
1581 case WODM_RESTART
: return wodRestart (wDevID
);
1582 case WODM_RESET
: return wodReset (wDevID
);
1584 case DRV_QUERYDEVICEINTERFACESIZE
: return wodDevInterfaceSize (wDevID
, (LPDWORD
)dwParam1
);
1585 case DRV_QUERYDEVICEINTERFACE
: return wodDevInterface (wDevID
, (PWCHAR
)dwParam1
, dwParam2
);
1586 case DRV_QUERYDSOUNDIFACE
: return wodDsCreate (wDevID
, (PIDSDRIVER
*)dwParam1
);
1587 case DRV_QUERYDSOUNDDESC
: return wodDsDesc (wDevID
, (PDSDRIVERDESC
)dwParam1
);
1589 FIXME("unknown message %d!\n", wMsg
);
1591 return MMSYSERR_NOTSUPPORTED
;
1594 /*======================================================================*
1595 * Low level WAVE IN implementation *
1596 *======================================================================*/
1598 /**************************************************************************
1599 * widGetNumDevs [internal]
1601 static DWORD
widGetNumDevs(void)
1603 TRACE("%d\n", MAX_WAVEINDRV
);
1604 return MAX_WAVEINDRV
;
1607 /**************************************************************************
1608 * widDevInterfaceSize [internal]
1610 static DWORD
widDevInterfaceSize(UINT wDevID
, LPDWORD dwParam1
)
1612 TRACE("(%u, %p)\n", wDevID
, dwParam1
);
1615 *dwParam1
= MultiByteToWideChar(CP_ACP
, 0, WInDev
[wDevID
].interface_name
, -1,
1616 NULL
, 0 ) * sizeof(WCHAR
);
1617 return MMSYSERR_NOERROR
;
1620 /**************************************************************************
1621 * widDevInterface [internal]
1623 static DWORD
widDevInterface(UINT wDevID
, PWCHAR dwParam1
, DWORD dwParam2
)
1625 if (dwParam2
>= MultiByteToWideChar(CP_ACP
, 0, WInDev
[wDevID
].interface_name
, -1,
1626 NULL
, 0 ) * sizeof(WCHAR
))
1628 MultiByteToWideChar(CP_ACP
, 0, WInDev
[wDevID
].interface_name
, -1,
1629 dwParam1
, dwParam2
/ sizeof(WCHAR
));
1630 return MMSYSERR_NOERROR
;
1632 return MMSYSERR_INVALPARAM
;
1635 /**************************************************************************
1636 * widNotifyClient [internal]
1638 static DWORD
widNotifyClient(WINE_WAVEIN
* wwi
, WORD wMsg
, DWORD_PTR dwParam1
,
1641 TRACE("wMsg = 0x%04x dwParm1 = %08lX dwParam2 = %08lX\n", wMsg
, dwParam1
, dwParam2
);
1647 if (wwi
->wFlags
!= DCB_NULL
&&
1648 !DriverCallback(wwi
->waveDesc
.dwCallback
, wwi
->wFlags
,
1649 (HDRVR
)wwi
->waveDesc
.hWave
, wMsg
,
1650 wwi
->waveDesc
.dwInstance
, dwParam1
, dwParam2
)) {
1651 WARN("can't notify client !\n");
1652 return MMSYSERR_ERROR
;
1656 FIXME("Unknown callback message %u\n", wMsg
);
1657 return MMSYSERR_INVALPARAM
;
1659 return MMSYSERR_NOERROR
;
1662 /**************************************************************************
1663 * widGetDevCaps [internal]
1665 static DWORD
widGetDevCaps(WORD wDevID
, LPWAVEINCAPSW lpCaps
, DWORD dwSize
)
1667 TRACE("(%u, %p, %u);\n", wDevID
, lpCaps
, dwSize
);
1669 if (lpCaps
== NULL
) return MMSYSERR_NOTENABLED
;
1671 if (wDevID
>= MAX_WAVEINDRV
) {
1672 TRACE("MAX_WAVINDRV reached !\n");
1673 return MMSYSERR_BADDEVICEID
;
1676 memcpy(lpCaps
, &WInDev
[wDevID
].caps
, min(dwSize
, sizeof(*lpCaps
)));
1677 return MMSYSERR_NOERROR
;
1680 /**************************************************************************
1681 * widRecorder [internal]
1683 static DWORD CALLBACK
widRecorder(LPVOID pmt
)
1685 WORD uDevID
= (DWORD_PTR
)pmt
;
1686 WINE_WAVEIN
* wwi
= &WInDev
[uDevID
];
1690 enum win_wm_message msg
;
1694 SetEvent(wwi
->hStartUpEvent
);
1696 /* make sleep time to be # of ms to record one packet */
1697 dwSleepTime
= (1024 * 1000) / wwi
->waveFormat
.Format
.nAvgBytesPerSec
;
1698 TRACE("sleeptime=%d ms\n", dwSleepTime
);
1701 TRACE("wwi->lpQueuePtr=(%p), wwi->state=(%d)\n",wwi
->lpQueuePtr
,wwi
->state
);
1703 /* read all data is esd input buffer. */
1704 if ((wwi
->lpQueuePtr
!= NULL
) && (wwi
->state
== WINE_WS_PLAYING
))
1706 lpWaveHdr
= wwi
->lpQueuePtr
;
1708 TRACE("read as much as we can\n");
1709 while(wwi
->lpQueuePtr
)
1711 TRACE("attempt to read %d bytes\n",lpWaveHdr
->dwBufferLength
- lpWaveHdr
->dwBytesRecorded
);
1712 bytesRead
= read(wwi
->esd_fd
,
1713 lpWaveHdr
->lpData
+ lpWaveHdr
->dwBytesRecorded
,
1714 lpWaveHdr
->dwBufferLength
- lpWaveHdr
->dwBytesRecorded
);
1715 TRACE("bytesRead=%d\n",bytesRead
);
1716 if (bytesRead
<= 0) break; /* So we can stop recording smoothly */
1718 lpWaveHdr
->dwBytesRecorded
+= bytesRead
;
1719 wwi
->dwRecordedTotal
+= bytesRead
;
1721 /* buffer full. notify client */
1722 if (lpWaveHdr
->dwBytesRecorded
>= lpWaveHdr
->dwBufferLength
)
1724 /* must copy the value of next waveHdr, because we have no idea of what
1725 * will be done with the content of lpWaveHdr in callback
1727 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
1729 TRACE("waveHdr full.\n");
1731 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
1732 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
1734 widNotifyClient(wwi
, WIM_DATA
, (DWORD_PTR
)lpWaveHdr
, 0);
1735 lpWaveHdr
= wwi
->lpQueuePtr
= lpNext
;
1740 /* wait for dwSleepTime or an event in thread's queue */
1741 WAIT_OMR(&wwi
->msgRing
, dwSleepTime
);
1743 while (ESD_RetrieveRingMessage(&wwi
->msgRing
, &msg
, ¶m
, &ev
))
1745 TRACE("msg=%s param=0x%lx\n",wodPlayerCmdString
[msg
- WM_USER
- 1], param
);
1747 case WINE_WM_PAUSING
:
1748 wwi
->state
= WINE_WS_PAUSED
;
1750 /* Put code here to "pause" esd recording
1755 case WINE_WM_STARTING
:
1756 wwi
->state
= WINE_WS_PLAYING
;
1758 /* Put code here to "start" esd recording
1763 case WINE_WM_HEADER
:
1764 lpWaveHdr
= (LPWAVEHDR
)param
;
1765 /* insert buffer at end of queue */
1768 int num_headers
= 0;
1769 for (wh
= &(wwi
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
))
1777 case WINE_WM_STOPPING
:
1778 if (wwi
->state
!= WINE_WS_STOPPED
)
1781 /* Put code here to "stop" esd recording
1784 /* return current buffer to app */
1785 lpWaveHdr
= wwi
->lpQueuePtr
;
1788 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
1789 TRACE("stop %p %p\n", lpWaveHdr
, lpWaveHdr
->lpNext
);
1790 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
1791 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
1792 widNotifyClient(wwi
, WIM_DATA
, (DWORD_PTR
)lpWaveHdr
, 0);
1793 wwi
->lpQueuePtr
= lpNext
;
1796 wwi
->state
= WINE_WS_STOPPED
;
1799 case WINE_WM_RESETTING
:
1800 wwi
->state
= WINE_WS_STOPPED
;
1801 wwi
->dwRecordedTotal
= 0;
1803 /* return all buffers to the app */
1804 for (lpWaveHdr
= wwi
->lpQueuePtr
; lpWaveHdr
; lpWaveHdr
= lpWaveHdr
->lpNext
) {
1805 TRACE("reset %p %p\n", lpWaveHdr
, lpWaveHdr
->lpNext
);
1806 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
1807 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
1809 widNotifyClient(wwi
, WIM_DATA
, (DWORD_PTR
)lpWaveHdr
, 0);
1811 wwi
->lpQueuePtr
= NULL
;
1814 case WINE_WM_CLOSING
:
1816 wwi
->state
= WINE_WS_CLOSED
;
1819 /* shouldn't go here */
1821 FIXME("unknown message %d\n", msg
);
1827 /* just for not generating compilation warnings... should never be executed */
1831 /**************************************************************************
1832 * widOpen [internal]
1834 static DWORD
widOpen(WORD wDevID
, LPWAVEOPENDESC lpDesc
, DWORD dwFlags
)
1837 /* input esound... */
1838 int in_bits
= ESD_BITS16
, in_channels
= ESD_STEREO
, in_rate
;
1839 #ifdef WID_USE_ESDMON
1840 int in_mode
= ESD_STREAM
, in_func
= ESD_PLAY
;
1842 int in_mode
= ESD_STREAM
, in_func
= ESD_RECORD
;
1844 esd_format_t in_format
;
1847 TRACE("(%u, %p %08X);\n",wDevID
, lpDesc
, dwFlags
);
1848 if (lpDesc
== NULL
) {
1849 WARN("Invalid Parametr (lpDesc == NULL)!\n");
1850 return MMSYSERR_INVALPARAM
;
1853 if (wDevID
>= MAX_WAVEINDRV
) {
1854 TRACE ("MAX_WAVEINDRV reached !\n");
1855 return MMSYSERR_BADDEVICEID
;
1858 /* if this device is already open tell the app that it is allocated */
1859 if(WInDev
[wDevID
].esd_fd
!= -1)
1861 TRACE("device already allocated\n");
1862 return MMSYSERR_ALLOCATED
;
1865 /* only PCM format is support so far... */
1866 if (!supportedFormat(lpDesc
->lpFormat
)) {
1867 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1868 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
1869 lpDesc
->lpFormat
->nSamplesPerSec
);
1870 return WAVERR_BADFORMAT
;
1873 if (dwFlags
& WAVE_FORMAT_QUERY
) {
1874 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1875 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
1876 lpDesc
->lpFormat
->nSamplesPerSec
);
1877 return MMSYSERR_NOERROR
;
1880 wwi
= &WInDev
[wDevID
];
1882 /* direct sound not supported, ignore the flag */
1883 dwFlags
&= ~WAVE_DIRECTSOUND
;
1885 wwi
->wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
1887 wwi
->waveDesc
= *lpDesc
;
1888 copy_format(lpDesc
->lpFormat
, &wwi
->waveFormat
);
1890 if (wwi
->waveFormat
.Format
.wBitsPerSample
== 0) {
1891 WARN("Resetting zerod wBitsPerSample\n");
1892 wwi
->waveFormat
.Format
.wBitsPerSample
= 8 *
1893 (wwi
->waveFormat
.Format
.nAvgBytesPerSec
/
1894 wwi
->waveFormat
.Format
.nSamplesPerSec
) /
1895 wwi
->waveFormat
.Format
.nChannels
;
1898 if (wwi
->waveFormat
.Format
.wBitsPerSample
== 8)
1899 in_bits
= ESD_BITS8
;
1900 else if (wwi
->waveFormat
.Format
.wBitsPerSample
== 16)
1901 in_bits
= ESD_BITS16
;
1903 wwi
->bytes_per_frame
= (wwi
->waveFormat
.Format
.wBitsPerSample
* wwi
->waveFormat
.Format
.nChannels
) / 8;
1905 if (wwi
->waveFormat
.Format
.nChannels
== 1)
1906 in_channels
= ESD_MONO
;
1907 else if (wwi
->waveFormat
.Format
.nChannels
== 2)
1908 in_channels
= ESD_STEREO
;
1910 in_format
= in_bits
| in_channels
| in_mode
| in_func
;
1911 in_rate
= (int) wwi
->waveFormat
.Format
.nSamplesPerSec
;
1912 TRACE("esd input format = 0x%08x, rate = %d\n", in_format
, in_rate
);
1914 #ifdef WID_USE_ESDMON
1915 wwi
->esd_fd
= esd_monitor_stream(in_format
, in_rate
, esd_host
, "wineesd");
1917 wwi
->esd_fd
= esd_record_stream(in_format
, in_rate
, esd_host
, "wineesd");
1919 TRACE("(wwi->esd_fd=%d)\n",wwi
->esd_fd
);
1920 wwi
->state
= WINE_WS_STOPPED
;
1922 if (wwi
->lpQueuePtr
) {
1923 WARN("Should have an empty queue (%p)\n", wwi
->lpQueuePtr
);
1924 wwi
->lpQueuePtr
= NULL
;
1927 if(wwi
->esd_fd
< 0) return MMSYSERR_ALLOCATED
;
1929 /* Set the esd socket O_NONBLOCK, so we can stop recording smoothly */
1930 mode
= fcntl(wwi
->esd_fd
, F_GETFL
);
1932 fcntl(wwi
->esd_fd
, F_SETFL
, mode
);
1934 wwi
->dwRecordedTotal
= 0;
1935 wwi
->wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
1937 ESD_InitRingMessage(&wwi
->msgRing
);
1939 /* create recorder thread */
1940 if (!(dwFlags
& WAVE_DIRECTSOUND
)) {
1941 wwi
->hStartUpEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1942 wwi
->hThread
= CreateThread(NULL
, 0, widRecorder
, (LPVOID
)(DWORD_PTR
)wDevID
,
1943 0, &(wwi
->dwThreadID
));
1944 WaitForSingleObject(wwi
->hStartUpEvent
, INFINITE
);
1945 CloseHandle(wwi
->hStartUpEvent
);
1947 wwi
->hThread
= INVALID_HANDLE_VALUE
;
1948 wwi
->dwThreadID
= 0;
1950 wwi
->hStartUpEvent
= INVALID_HANDLE_VALUE
;
1952 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
1953 wwi
->waveFormat
.Format
.wBitsPerSample
, wwi
->waveFormat
.Format
.nAvgBytesPerSec
,
1954 wwi
->waveFormat
.Format
.nSamplesPerSec
, wwi
->waveFormat
.Format
.nChannels
,
1955 wwi
->waveFormat
.Format
.nBlockAlign
);
1956 return widNotifyClient(wwi
, WIM_OPEN
, 0L, 0L);
1959 /**************************************************************************
1960 * widClose [internal]
1962 static DWORD
widClose(WORD wDevID
)
1966 TRACE("(%u);\n", wDevID
);
1967 if (wDevID
>= MAX_WAVEINDRV
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
1968 WARN("can't close !\n");
1969 return MMSYSERR_INVALHANDLE
;
1972 wwi
= &WInDev
[wDevID
];
1974 if (wwi
->lpQueuePtr
!= NULL
) {
1975 WARN("still buffers open !\n");
1976 return WAVERR_STILLPLAYING
;
1979 ESD_AddRingMessage(&wwi
->msgRing
, WINE_WM_CLOSING
, 0, TRUE
);
1980 ESD_CloseWaveInDevice(wwi
);
1981 wwi
->state
= WINE_WS_CLOSED
;
1982 ESD_DestroyRingMessage(&wwi
->msgRing
);
1983 return widNotifyClient(wwi
, WIM_CLOSE
, 0L, 0L);
1986 /**************************************************************************
1987 * widAddBuffer [internal]
1989 static DWORD
widAddBuffer(WORD wDevID
, LPWAVEHDR lpWaveHdr
, DWORD dwSize
)
1991 TRACE("(%u, %p, %08X);\n", wDevID
, lpWaveHdr
, dwSize
);
1993 if (wDevID
>= MAX_WAVEINDRV
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
1994 WARN("can't do it !\n");
1995 return MMSYSERR_INVALHANDLE
;
1997 if (!(lpWaveHdr
->dwFlags
& WHDR_PREPARED
)) {
1998 TRACE("never been prepared !\n");
1999 return WAVERR_UNPREPARED
;
2001 if (lpWaveHdr
->dwFlags
& WHDR_INQUEUE
) {
2002 TRACE("header already in use !\n");
2003 return WAVERR_STILLPLAYING
;
2006 lpWaveHdr
->dwFlags
|= WHDR_INQUEUE
;
2007 lpWaveHdr
->dwFlags
&= ~WHDR_DONE
;
2008 lpWaveHdr
->dwBytesRecorded
= 0;
2009 lpWaveHdr
->lpNext
= NULL
;
2011 ESD_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_HEADER
,
2012 (DWORD_PTR
)lpWaveHdr
, FALSE
);
2013 return MMSYSERR_NOERROR
;
2016 /**************************************************************************
2017 * widStart [internal]
2019 static DWORD
widStart(WORD wDevID
)
2021 TRACE("(%u);\n", wDevID
);
2022 if (wDevID
>= MAX_WAVEINDRV
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2023 WARN("can't start recording !\n");
2024 return MMSYSERR_INVALHANDLE
;
2027 ESD_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_STARTING
, 0, TRUE
);
2028 return MMSYSERR_NOERROR
;
2031 /**************************************************************************
2032 * widStop [internal]
2034 static DWORD
widStop(WORD wDevID
)
2036 TRACE("(%u);\n", wDevID
);
2037 if (wDevID
>= MAX_WAVEINDRV
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2038 WARN("can't stop !\n");
2039 return MMSYSERR_INVALHANDLE
;
2042 ESD_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_STOPPING
, 0, TRUE
);
2044 return MMSYSERR_NOERROR
;
2047 /**************************************************************************
2048 * widReset [internal]
2050 static DWORD
widReset(WORD wDevID
)
2052 TRACE("(%u);\n", wDevID
);
2053 if (wDevID
>= MAX_WAVEINDRV
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2054 WARN("can't reset !\n");
2055 return MMSYSERR_INVALHANDLE
;
2057 ESD_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_RESETTING
, 0, TRUE
);
2058 return MMSYSERR_NOERROR
;
2061 /**************************************************************************
2062 * widMessage (WINEESD.6)
2064 DWORD WINAPI
ESD_widMessage(UINT wDevID
, UINT wMsg
, DWORD dwUser
,
2065 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2067 TRACE("(%u, %04X, %08X, %08lX, %08lX);\n",
2068 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
2074 /* FIXME: Pretend this is supported */
2076 case WIDM_OPEN
: return widOpen (wDevID
, (LPWAVEOPENDESC
)dwParam1
, dwParam2
);
2077 case WIDM_CLOSE
: return widClose (wDevID
);
2078 case WIDM_ADDBUFFER
: return widAddBuffer (wDevID
, (LPWAVEHDR
)dwParam1
, dwParam2
);
2079 case WIDM_PREPARE
: return MMSYSERR_NOTSUPPORTED
;
2080 case WIDM_UNPREPARE
: return MMSYSERR_NOTSUPPORTED
;
2081 case WIDM_GETDEVCAPS
: return widGetDevCaps (wDevID
, (LPWAVEINCAPSW
)dwParam1
, dwParam2
);
2082 case WIDM_GETNUMDEVS
: return widGetNumDevs ();
2083 case WIDM_RESET
: return widReset (wDevID
);
2084 case WIDM_START
: return widStart (wDevID
);
2085 case WIDM_STOP
: return widStop (wDevID
);
2086 case DRV_QUERYDEVICEINTERFACESIZE
: return widDevInterfaceSize (wDevID
, (LPDWORD
)dwParam1
);
2087 case DRV_QUERYDEVICEINTERFACE
: return widDevInterface (wDevID
, (PWCHAR
)dwParam1
, dwParam2
);
2089 FIXME("unknown message %d!\n", wMsg
);
2091 return MMSYSERR_NOTSUPPORTED
;
2094 /*======================================================================*
2095 * Low level DSOUND implementation *
2096 *======================================================================*/
2097 static DWORD
wodDsCreate(UINT wDevID
, PIDSDRIVER
* drv
)
2099 /* we can't perform memory mapping as we don't have a file stream
2100 interface with esd like we do with oss */
2101 MESSAGE("This sound card's driver does not support direct access\n");
2102 MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
2103 return MMSYSERR_NOTSUPPORTED
;
2106 static DWORD
wodDsDesc(UINT wDevID
, PDSDRIVERDESC desc
)
2108 memset(desc
, 0, sizeof(*desc
));
2109 strcpy(desc
->szDesc
, "Wine EsounD DirectSound Driver");
2110 strcpy(desc
->szDrvname
, "wineesd.drv");
2111 return MMSYSERR_NOERROR
;
2114 #else /* !HAVE_ESD */
2116 /**************************************************************************
2117 * wodMessage (WINEESD.@)
2119 DWORD WINAPI
ESD_wodMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
2120 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2122 FIXME("(%u, %04X, %08X, %08lX, %08lX):stub\n", wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
2123 return MMSYSERR_NOTENABLED
;
2126 /**************************************************************************
2127 * widMessage (WINEESD.6)
2129 DWORD WINAPI
ESD_widMessage(UINT wDevID
, UINT wMsg
, DWORD dwUser
,
2130 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2132 FIXME("(%u, %04X, %08X, %08lX, %08lX):stub\n", wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
2133 return MMSYSERR_NOTENABLED
;
2136 #endif /* HAVE_ESD */