2 * Sample Wine Driver for Advanced Linux Sound System (ALSA)
3 * Based on version <final> of the ALSA API
5 * Copyright 2002 Eric Pouech
6 * 2002 Marco Pietrobono
7 * 2003 Christian Costa : WaveIn support
8 * 2006-2007 Maarten Lankhorst
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 /*======================================================================*
26 * Low level WAVE IN implementation *
27 *======================================================================*/
30 #include "wine/port.h"
42 #ifdef HAVE_SYS_IOCTL_H
43 # include <sys/ioctl.h>
45 #ifdef HAVE_SYS_MMAN_H
46 # include <sys/mman.h>
56 #include "wine/library.h"
57 #include "wine/unicode.h"
58 #include "wine/debug.h"
60 WINE_DEFAULT_DEBUG_CHANNEL(wave
);
65 DWORD ALSA_WidNumMallocedDevs
;
66 DWORD ALSA_WidNumDevs
;
68 /**************************************************************************
69 * widNotifyClient [internal]
71 static DWORD
widNotifyClient(WINE_WAVEDEV
* wwi
, WORD wMsg
, DWORD dwParam1
, DWORD dwParam2
)
73 TRACE("wMsg = 0x%04x dwParm1 = %04X dwParam2 = %04X\n", wMsg
, dwParam1
, dwParam2
);
79 if (wwi
->wFlags
!= DCB_NULL
&&
80 !DriverCallback(wwi
->waveDesc
.dwCallback
, wwi
->wFlags
, (HDRVR
)wwi
->waveDesc
.hWave
,
81 wMsg
, wwi
->waveDesc
.dwInstance
, dwParam1
, dwParam2
)) {
82 WARN("can't notify client !\n");
83 return MMSYSERR_ERROR
;
87 FIXME("Unknown callback message %u\n", wMsg
);
88 return MMSYSERR_INVALPARAM
;
90 return MMSYSERR_NOERROR
;
93 /**************************************************************************
94 * widGetDevCaps [internal]
96 static DWORD
widGetDevCaps(WORD wDevID
, LPWAVEINCAPSW lpCaps
, DWORD dwSize
)
98 TRACE("(%u, %p, %u);\n", wDevID
, lpCaps
, dwSize
);
100 if (lpCaps
== NULL
) return MMSYSERR_NOTENABLED
;
102 if (wDevID
>= ALSA_WidNumDevs
) {
103 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
104 return MMSYSERR_BADDEVICEID
;
107 memcpy(lpCaps
, &WInDev
[wDevID
].incaps
, min(dwSize
, sizeof(*lpCaps
)));
108 return MMSYSERR_NOERROR
;
111 /**************************************************************************
112 * widRecorder_ReadHeaders [internal]
114 static void widRecorder_ReadHeaders(WINE_WAVEDEV
* wwi
)
116 enum win_wm_message tmp_msg
;
121 while (ALSA_RetrieveRingMessage(&wwi
->msgRing
, &tmp_msg
, &tmp_param
, &tmp_ev
)) {
122 if (tmp_msg
== WINE_WM_HEADER
) {
124 lpWaveHdr
= (LPWAVEHDR
)tmp_param
;
125 lpWaveHdr
->lpNext
= 0;
127 if (wwi
->lpQueuePtr
== 0)
128 wwi
->lpQueuePtr
= lpWaveHdr
;
130 for (wh
= &(wwi
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
134 ERR("should only have headers left\n");
139 /**************************************************************************
140 * widRecorder [internal]
142 static DWORD CALLBACK
widRecorder(LPVOID pmt
)
144 WORD uDevID
= (DWORD
)pmt
;
145 WINE_WAVEDEV
* wwi
= (WINE_WAVEDEV
*)&WInDev
[uDevID
];
149 LPVOID buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, wwi
->dwPeriodSize
);
150 char *pOffset
= buffer
;
151 enum win_wm_message msg
;
154 DWORD frames_per_period
;
156 wwi
->state
= WINE_WS_STOPPED
;
157 InterlockedExchange((LONG
*)&wwi
->dwTotalRecorded
, 0);
158 wwi
->lpQueuePtr
= NULL
;
160 SetEvent(wwi
->hStartUpEvent
);
162 /* make sleep time to be # of ms to output a period */
163 dwSleepTime
= (1024/*wwi-dwPeriodSize => overrun!*/ * 1000) / wwi
->format
.Format
.nAvgBytesPerSec
;
164 frames_per_period
= snd_pcm_bytes_to_frames(wwi
->pcm
, wwi
->dwPeriodSize
);
165 TRACE("sleeptime=%d ms\n", dwSleepTime
);
168 /* wait for dwSleepTime or an event in thread's queue */
169 /* FIXME: could improve wait time depending on queue state,
170 * ie, number of queued fragments
172 if (wwi
->lpQueuePtr
!= NULL
&& wwi
->state
== WINE_WS_PLAYING
)
179 lpWaveHdr
= wwi
->lpQueuePtr
;
180 /* read all the fragments accumulated so far */
181 frames
= snd_pcm_avail_update(wwi
->pcm
);
182 bytes
= snd_pcm_frames_to_bytes(wwi
->pcm
, frames
);
183 TRACE("frames = %d bytes = %d\n", frames
, bytes
);
184 periods
= bytes
/ wwi
->dwPeriodSize
;
185 while ((periods
> 0) && (wwi
->lpQueuePtr
))
188 bytes
= wwi
->dwPeriodSize
;
189 TRACE("bytes = %d\n",bytes
);
190 if (lpWaveHdr
->dwBufferLength
- lpWaveHdr
->dwBytesRecorded
>= wwi
->dwPeriodSize
)
192 /* directly read fragment in wavehdr */
193 read
= wwi
->read(wwi
->pcm
, lpWaveHdr
->lpData
+ lpWaveHdr
->dwBytesRecorded
, frames_per_period
);
194 bytesRead
= snd_pcm_frames_to_bytes(wwi
->pcm
, read
);
196 TRACE("bytesRead=%d (direct)\n", bytesRead
);
197 if (bytesRead
!= (DWORD
) -1)
199 /* update number of bytes recorded in current buffer and by this device */
200 lpWaveHdr
->dwBytesRecorded
+= bytesRead
;
201 InterlockedExchangeAdd((LONG
*)&wwi
->dwTotalRecorded
, bytesRead
);
203 /* buffer is full. notify client */
204 if (lpWaveHdr
->dwBytesRecorded
== lpWaveHdr
->dwBufferLength
)
206 /* must copy the value of next waveHdr, because we have no idea of what
207 * will be done with the content of lpWaveHdr in callback
209 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
211 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
212 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
214 wwi
->lpQueuePtr
= lpNext
;
215 widNotifyClient(wwi
, WIM_DATA
, (DWORD
)lpWaveHdr
, 0);
219 TRACE("read(%s, %p, %d) failed (%s)\n", wwi
->pcmname
,
220 lpWaveHdr
->lpData
+ lpWaveHdr
->dwBytesRecorded
,
221 frames_per_period
, strerror(errno
));
226 /* read the fragment in a local buffer */
227 read
= wwi
->read(wwi
->pcm
, buffer
, frames_per_period
);
228 bytesRead
= snd_pcm_frames_to_bytes(wwi
->pcm
, read
);
231 TRACE("bytesRead=%d (local)\n", bytesRead
);
233 if (bytesRead
== (DWORD
) -1) {
234 TRACE("read(%s, %p, %d) failed (%s)\n", wwi
->pcmname
,
235 buffer
, frames_per_period
, strerror(errno
));
239 /* copy data in client buffers */
240 while (bytesRead
!= (DWORD
) -1 && bytesRead
> 0)
242 DWORD dwToCopy
= min (bytesRead
, lpWaveHdr
->dwBufferLength
- lpWaveHdr
->dwBytesRecorded
);
244 memcpy(lpWaveHdr
->lpData
+ lpWaveHdr
->dwBytesRecorded
,
248 /* update number of bytes recorded in current buffer and by this device */
249 lpWaveHdr
->dwBytesRecorded
+= dwToCopy
;
250 InterlockedExchangeAdd((LONG
*)&wwi
->dwTotalRecorded
, dwToCopy
);
251 bytesRead
-= dwToCopy
;
254 /* client buffer is full. notify client */
255 if (lpWaveHdr
->dwBytesRecorded
== lpWaveHdr
->dwBufferLength
)
257 /* must copy the value of next waveHdr, because we have no idea of what
258 * will be done with the content of lpWaveHdr in callback
260 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
261 TRACE("lpNext=%p\n", lpNext
);
263 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
264 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
266 wwi
->lpQueuePtr
= lpNext
;
267 widNotifyClient(wwi
, WIM_DATA
, (DWORD
)lpWaveHdr
, 0);
270 if (!lpNext
&& bytesRead
) {
271 /* before we give up, check for more header messages */
272 while (ALSA_PeekRingMessage(&wwi
->msgRing
, &msg
, ¶m
, &ev
))
274 if (msg
== WINE_WM_HEADER
) {
276 ALSA_RetrieveRingMessage(&wwi
->msgRing
, &msg
, ¶m
, &ev
);
277 hdr
= ((LPWAVEHDR
)param
);
278 TRACE("msg = %s, hdr = %p, ev = %p\n", ALSA_getCmdString(msg
), hdr
, ev
);
280 if (lpWaveHdr
== 0) {
281 /* new head of queue */
282 wwi
->lpQueuePtr
= lpWaveHdr
= hdr
;
284 /* insert buffer at the end of queue */
286 for (wh
= &(wwi
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
293 if (lpWaveHdr
== 0) {
294 /* no more buffer to copy data to, but we did read more.
295 * what hasn't been copied will be dropped
297 WARN("buffer under run! %u bytes dropped.\n", bytesRead
);
298 wwi
->lpQueuePtr
= NULL
;
308 ALSA_WaitRingMessage(&wwi
->msgRing
, dwSleepTime
);
310 while (ALSA_RetrieveRingMessage(&wwi
->msgRing
, &msg
, ¶m
, &ev
))
312 TRACE("msg=%s param=0x%x\n", ALSA_getCmdString(msg
), param
);
314 case WINE_WM_PAUSING
:
315 wwi
->state
= WINE_WS_PAUSED
;
316 /*FIXME("Device should stop recording\n");*/
319 case WINE_WM_STARTING
:
320 wwi
->state
= WINE_WS_PLAYING
;
321 snd_pcm_start(wwi
->pcm
);
325 lpWaveHdr
= (LPWAVEHDR
)param
;
326 lpWaveHdr
->lpNext
= 0;
328 /* insert buffer at the end of queue */
331 for (wh
= &(wwi
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
335 case WINE_WM_STOPPING
:
336 if (wwi
->state
!= WINE_WS_STOPPED
)
338 snd_pcm_drain(wwi
->pcm
);
340 /* read any headers in queue */
341 widRecorder_ReadHeaders(wwi
);
343 /* return current buffer to app */
344 lpWaveHdr
= wwi
->lpQueuePtr
;
347 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
348 TRACE("stop %p %p\n", lpWaveHdr
, lpWaveHdr
->lpNext
);
349 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
350 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
351 wwi
->lpQueuePtr
= lpNext
;
352 widNotifyClient(wwi
, WIM_DATA
, (DWORD
)lpWaveHdr
, 0);
355 wwi
->state
= WINE_WS_STOPPED
;
358 case WINE_WM_RESETTING
:
359 if (wwi
->state
!= WINE_WS_STOPPED
)
361 snd_pcm_drain(wwi
->pcm
);
363 wwi
->state
= WINE_WS_STOPPED
;
364 wwi
->dwTotalRecorded
= 0;
366 /* read any headers in queue */
367 widRecorder_ReadHeaders(wwi
);
369 /* return all buffers to the app */
370 for (lpWaveHdr
= wwi
->lpQueuePtr
; lpWaveHdr
; lpWaveHdr
= lpWaveHdr
->lpNext
) {
371 TRACE("reset %p %p\n", lpWaveHdr
, lpWaveHdr
->lpNext
);
372 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
373 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
374 wwi
->lpQueuePtr
= lpWaveHdr
->lpNext
;
375 widNotifyClient(wwi
, WIM_DATA
, (DWORD
)lpWaveHdr
, 0);
378 wwi
->lpQueuePtr
= NULL
;
381 case WINE_WM_CLOSING
:
383 wwi
->state
= WINE_WS_CLOSED
;
385 HeapFree(GetProcessHeap(), 0, buffer
);
387 /* shouldn't go here */
389 FIXME("unknown message %d\n", msg
);
395 /* just for not generating compilation warnings... should never be executed */
399 /**************************************************************************
402 static DWORD
widOpen(WORD wDevID
, LPWAVEOPENDESC lpDesc
, DWORD dwFlags
)
405 snd_pcm_hw_params_t
* hw_params
;
406 snd_pcm_sw_params_t
* sw_params
;
407 snd_pcm_access_t access
;
408 snd_pcm_format_t format
;
410 unsigned int buffer_time
= 500000;
411 unsigned int period_time
= 10000;
412 snd_pcm_uframes_t buffer_size
;
413 snd_pcm_uframes_t period_size
;
419 snd_pcm_hw_params_alloca(&hw_params
);
420 snd_pcm_sw_params_alloca(&sw_params
);
422 /* JPW TODO - review this code */
423 TRACE("(%u, %p, %08X);\n", wDevID
, lpDesc
, dwFlags
);
424 if (lpDesc
== NULL
) {
425 WARN("Invalid Parameter !\n");
426 return MMSYSERR_INVALPARAM
;
428 if (wDevID
>= ALSA_WidNumDevs
) {
429 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
430 return MMSYSERR_BADDEVICEID
;
433 /* only PCM format is supported so far... */
434 if (!ALSA_supportedFormat(lpDesc
->lpFormat
)) {
435 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
436 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
437 lpDesc
->lpFormat
->nSamplesPerSec
);
438 return WAVERR_BADFORMAT
;
441 if (dwFlags
& WAVE_FORMAT_QUERY
) {
442 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
443 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
444 lpDesc
->lpFormat
->nSamplesPerSec
);
445 return MMSYSERR_NOERROR
;
448 wwi
= &WInDev
[wDevID
];
450 if (wwi
->pcm
!= NULL
) {
451 WARN("already allocated\n");
452 return MMSYSERR_ALLOCATED
;
455 if ((dwFlags
& WAVE_DIRECTSOUND
) && !(wwi
->dwSupport
& WAVECAPS_DIRECTSOUND
))
456 /* not supported, ignore it */
457 dwFlags
&= ~WAVE_DIRECTSOUND
;
460 flags
= SND_PCM_NONBLOCK
;
462 if ( (err
=snd_pcm_open(&pcm
, wwi
->pcmname
, SND_PCM_STREAM_CAPTURE
, flags
)) < 0 )
464 ERR("Error open: %s\n", snd_strerror(err
));
465 return MMSYSERR_NOTENABLED
;
468 wwi
->wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
470 memcpy(&wwi
->waveDesc
, lpDesc
, sizeof(WAVEOPENDESC
));
471 ALSA_copyFormat(lpDesc
->lpFormat
, &wwi
->format
);
473 if (wwi
->format
.Format
.wBitsPerSample
== 0) {
474 WARN("Resetting zeroed wBitsPerSample\n");
475 wwi
->format
.Format
.wBitsPerSample
= 8 *
476 (wwi
->format
.Format
.nAvgBytesPerSec
/
477 wwi
->format
.Format
.nSamplesPerSec
) /
478 wwi
->format
.Format
.nChannels
;
481 snd_pcm_hw_params_any(pcm
, hw_params
);
483 #define EXIT_ON_ERROR(f,e,txt) do \
486 if ( (err = (f) ) < 0) \
488 WARN(txt ": %s\n", snd_strerror(err)); \
489 snd_pcm_close(pcm); \
494 access
= SND_PCM_ACCESS_MMAP_INTERLEAVED
;
495 if ( ( err
= snd_pcm_hw_params_set_access(pcm
, hw_params
, access
) ) < 0) {
496 WARN("mmap not available. switching to standard write.\n");
497 access
= SND_PCM_ACCESS_RW_INTERLEAVED
;
498 EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm
, hw_params
, access
), MMSYSERR_INVALPARAM
, "unable to set access for playback");
499 wwi
->read
= snd_pcm_readi
;
502 wwi
->read
= snd_pcm_mmap_readi
;
504 EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm
, hw_params
, wwi
->format
.Format
.nChannels
), WAVERR_BADFORMAT
, "unable to set required channels");
506 if ((wwi
->format
.Format
.wFormatTag
== WAVE_FORMAT_PCM
) ||
507 ((wwi
->format
.Format
.wFormatTag
== WAVE_FORMAT_EXTENSIBLE
) &&
508 IsEqualGUID(&wwi
->format
.SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))) {
509 format
= (wwi
->format
.Format
.wBitsPerSample
== 8) ? SND_PCM_FORMAT_U8
:
510 (wwi
->format
.Format
.wBitsPerSample
== 16) ? SND_PCM_FORMAT_S16_LE
:
511 (wwi
->format
.Format
.wBitsPerSample
== 24) ? SND_PCM_FORMAT_S24_LE
:
512 (wwi
->format
.Format
.wBitsPerSample
== 32) ? SND_PCM_FORMAT_S32_LE
: -1;
513 } else if ((wwi
->format
.Format
.wFormatTag
== WAVE_FORMAT_EXTENSIBLE
) &&
514 IsEqualGUID(&wwi
->format
.SubFormat
, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
)){
515 format
= (wwi
->format
.Format
.wBitsPerSample
== 32) ? SND_PCM_FORMAT_FLOAT_LE
: -1;
516 } else if (wwi
->format
.Format
.wFormatTag
== WAVE_FORMAT_MULAW
) {
517 FIXME("unimplemented format: WAVE_FORMAT_MULAW\n");
519 return WAVERR_BADFORMAT
;
520 } else if (wwi
->format
.Format
.wFormatTag
== WAVE_FORMAT_ALAW
) {
521 FIXME("unimplemented format: WAVE_FORMAT_ALAW\n");
523 return WAVERR_BADFORMAT
;
524 } else if (wwi
->format
.Format
.wFormatTag
== WAVE_FORMAT_ADPCM
) {
525 FIXME("unimplemented format: WAVE_FORMAT_ADPCM\n");
527 return WAVERR_BADFORMAT
;
529 ERR("invalid format: %0x04x\n", wwi
->format
.Format
.wFormatTag
);
531 return WAVERR_BADFORMAT
;
534 EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm
, hw_params
, format
), WAVERR_BADFORMAT
, "unable to set required format");
536 rate
= wwi
->format
.Format
.nSamplesPerSec
;
538 err
= snd_pcm_hw_params_set_rate_near(pcm
, hw_params
, &rate
, &dir
);
540 WARN("Rate %d Hz not available for playback: %s\n", wwi
->format
.Format
.nSamplesPerSec
, snd_strerror(rate
));
542 return WAVERR_BADFORMAT
;
544 if (!ALSA_NearMatch(rate
, wwi
->format
.Format
.nSamplesPerSec
)) {
545 WARN("Rate doesn't match (requested %d Hz, got %d Hz)\n", wwi
->format
.Format
.nSamplesPerSec
, rate
);
547 return WAVERR_BADFORMAT
;
551 EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm
, hw_params
, &buffer_time
, &dir
), MMSYSERR_INVALPARAM
, "unable to set buffer time");
553 EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm
, hw_params
, &period_time
, &dir
), MMSYSERR_INVALPARAM
, "unable to set period time");
555 EXIT_ON_ERROR( snd_pcm_hw_params(pcm
, hw_params
), MMSYSERR_INVALPARAM
, "unable to set hw params for playback");
558 err
= snd_pcm_hw_params_get_period_size(hw_params
, &period_size
, &dir
);
559 err
= snd_pcm_hw_params_get_buffer_size(hw_params
, &buffer_size
);
561 snd_pcm_sw_params_current(pcm
, sw_params
);
562 EXIT_ON_ERROR( snd_pcm_sw_params_set_start_threshold(pcm
, sw_params
, dwFlags
& WAVE_DIRECTSOUND
? INT_MAX
: 1 ), MMSYSERR_ERROR
, "unable to set start threshold");
563 EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm
, sw_params
, 0), MMSYSERR_ERROR
, "unable to set silence size");
564 EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm
, sw_params
, period_size
), MMSYSERR_ERROR
, "unable to set avail min");
565 EXIT_ON_ERROR( snd_pcm_sw_params_set_xfer_align(pcm
, sw_params
, 1), MMSYSERR_ERROR
, "unable to set xfer align");
566 EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm
, sw_params
, 0), MMSYSERR_ERROR
, "unable to set silence threshold");
567 EXIT_ON_ERROR( snd_pcm_sw_params(pcm
, sw_params
), MMSYSERR_ERROR
, "unable to set sw params for playback");
570 snd_pcm_prepare(pcm
);
573 ALSA_TraceParameters(hw_params
, sw_params
, FALSE
);
575 /* now, we can save all required data for later use... */
576 if ( wwi
->hw_params
)
577 snd_pcm_hw_params_free(wwi
->hw_params
);
578 snd_pcm_hw_params_malloc(&(wwi
->hw_params
));
579 snd_pcm_hw_params_copy(wwi
->hw_params
, hw_params
);
581 wwi
->dwBufferSize
= snd_pcm_frames_to_bytes(pcm
, buffer_size
);
582 wwi
->lpQueuePtr
= wwi
->lpPlayPtr
= wwi
->lpLoopPtr
= NULL
;
585 ALSA_InitRingMessage(&wwi
->msgRing
);
587 wwi
->dwPeriodSize
= period_size
;
588 /*if (wwi->dwFragmentSize % wwi->format.Format.nBlockAlign)
589 ERR("Fragment doesn't contain an integral number of data blocks\n");
591 TRACE("dwPeriodSize=%u\n", wwi
->dwPeriodSize
);
592 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
593 wwi
->format
.Format
.wBitsPerSample
, wwi
->format
.Format
.nAvgBytesPerSec
,
594 wwi
->format
.Format
.nSamplesPerSec
, wwi
->format
.Format
.nChannels
,
595 wwi
->format
.Format
.nBlockAlign
);
597 if (!(dwFlags
& WAVE_DIRECTSOUND
)) {
598 wwi
->hStartUpEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
599 wwi
->hThread
= CreateThread(NULL
, 0, widRecorder
, (LPVOID
)(DWORD
)wDevID
, 0, &(wwi
->dwThreadID
));
601 SetThreadPriority(wwi
->hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
602 WaitForSingleObject(wwi
->hStartUpEvent
, INFINITE
);
603 CloseHandle(wwi
->hStartUpEvent
);
605 wwi
->hThread
= INVALID_HANDLE_VALUE
;
608 wwi
->hStartUpEvent
= INVALID_HANDLE_VALUE
;
610 return widNotifyClient(wwi
, WIM_OPEN
, 0L, 0L);
614 /**************************************************************************
615 * widClose [internal]
617 static DWORD
widClose(WORD wDevID
)
619 DWORD ret
= MMSYSERR_NOERROR
;
622 TRACE("(%u);\n", wDevID
);
624 if (wDevID
>= ALSA_WidNumDevs
) {
625 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
626 return MMSYSERR_BADDEVICEID
;
629 if (WInDev
[wDevID
].pcm
== NULL
) {
630 WARN("Requested to close already closed device %d!\n", wDevID
);
631 return MMSYSERR_BADDEVICEID
;
634 wwi
= &WInDev
[wDevID
];
635 if (wwi
->lpQueuePtr
) {
636 WARN("buffers still playing !\n");
637 ret
= WAVERR_STILLPLAYING
;
639 if (wwi
->hThread
!= INVALID_HANDLE_VALUE
) {
640 ALSA_AddRingMessage(&wwi
->msgRing
, WINE_WM_CLOSING
, 0, TRUE
);
642 ALSA_DestroyRingMessage(&wwi
->msgRing
);
644 snd_pcm_hw_params_free(wwi
->hw_params
);
645 wwi
->hw_params
= NULL
;
647 snd_pcm_close(wwi
->pcm
);
650 ret
= widNotifyClient(wwi
, WIM_CLOSE
, 0L, 0L);
656 /**************************************************************************
657 * widAddBuffer [internal]
660 static DWORD
widAddBuffer(WORD wDevID
, LPWAVEHDR lpWaveHdr
, DWORD dwSize
)
662 TRACE("(%u, %p, %08X);\n", wDevID
, lpWaveHdr
, dwSize
);
664 /* first, do the sanity checks... */
665 if (wDevID
>= ALSA_WidNumDevs
) {
666 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
667 return MMSYSERR_BADDEVICEID
;
670 if (WInDev
[wDevID
].pcm
== NULL
) {
671 WARN("Requested to add buffer to already closed device %d!\n", wDevID
);
672 return MMSYSERR_BADDEVICEID
;
675 if (lpWaveHdr
->lpData
== NULL
|| !(lpWaveHdr
->dwFlags
& WHDR_PREPARED
))
676 return WAVERR_UNPREPARED
;
678 if (lpWaveHdr
->dwFlags
& WHDR_INQUEUE
)
679 return WAVERR_STILLPLAYING
;
681 lpWaveHdr
->dwFlags
&= ~WHDR_DONE
;
682 lpWaveHdr
->dwFlags
|= WHDR_INQUEUE
;
683 lpWaveHdr
->lpNext
= 0;
685 ALSA_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_HEADER
, (DWORD
)lpWaveHdr
, FALSE
);
687 return MMSYSERR_NOERROR
;
690 /**************************************************************************
691 * widStart [internal]
694 static DWORD
widStart(WORD wDevID
, LPWAVEHDR lpWaveHdr
, DWORD dwSize
)
696 TRACE("(%u, %p, %08X);\n", wDevID
, lpWaveHdr
, dwSize
);
698 /* first, do the sanity checks... */
699 if (wDevID
>= ALSA_WidNumDevs
) {
700 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
701 return MMSYSERR_BADDEVICEID
;
704 if (WInDev
[wDevID
].pcm
== NULL
) {
705 WARN("Requested to start closed device %d!\n", wDevID
);
706 return MMSYSERR_BADDEVICEID
;
709 ALSA_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_STARTING
, 0, TRUE
);
711 return MMSYSERR_NOERROR
;
714 /**************************************************************************
718 static DWORD
widStop(WORD wDevID
, LPWAVEHDR lpWaveHdr
, DWORD dwSize
)
720 TRACE("(%u, %p, %08X);\n", wDevID
, lpWaveHdr
, dwSize
);
722 /* first, do the sanity checks... */
723 if (wDevID
>= ALSA_WidNumDevs
) {
724 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
725 return MMSYSERR_BADDEVICEID
;
728 if (WInDev
[wDevID
].pcm
== NULL
) {
729 WARN("Requested to stop closed device %d!\n", wDevID
);
730 return MMSYSERR_BADDEVICEID
;
733 ALSA_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_STOPPING
, 0, TRUE
);
735 return MMSYSERR_NOERROR
;
738 /**************************************************************************
739 * widReset [internal]
741 static DWORD
widReset(WORD wDevID
)
743 TRACE("(%u);\n", wDevID
);
744 if (wDevID
>= ALSA_WidNumDevs
) {
745 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
746 return MMSYSERR_BADDEVICEID
;
749 if (WInDev
[wDevID
].pcm
== NULL
) {
750 WARN("Requested to reset closed device %d!\n", wDevID
);
751 return MMSYSERR_BADDEVICEID
;
754 ALSA_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_RESETTING
, 0, TRUE
);
755 return MMSYSERR_NOERROR
;
758 /**************************************************************************
759 * widGetPosition [internal]
761 static DWORD
widGetPosition(WORD wDevID
, LPMMTIME lpTime
, DWORD uSize
)
765 TRACE("(%u, %p, %u);\n", wDevID
, lpTime
, uSize
);
767 if (wDevID
>= ALSA_WidNumDevs
) {
768 TRACE("Requested device %d, but only %d are known!\n", wDevID
, ALSA_WidNumDevs
);
769 return MMSYSERR_BADDEVICEID
;
772 if (WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
773 WARN("Requested position of closed device %d!\n", wDevID
);
774 return MMSYSERR_BADDEVICEID
;
777 if (lpTime
== NULL
) {
778 WARN("invalid parameter: lpTime = NULL\n");
779 return MMSYSERR_INVALPARAM
;
782 wwi
= &WInDev
[wDevID
];
783 return ALSA_bytes_to_mmtime(lpTime
, wwi
->dwTotalRecorded
, &wwi
->format
);
786 /**************************************************************************
787 * widGetNumDevs [internal]
789 static DWORD
widGetNumDevs(void)
791 return ALSA_WidNumDevs
;
794 /**************************************************************************
795 * widDevInterfaceSize [internal]
797 static DWORD
widDevInterfaceSize(UINT wDevID
, LPDWORD dwParam1
)
799 TRACE("(%u, %p)\n", wDevID
, dwParam1
);
801 *dwParam1
= MultiByteToWideChar(CP_ACP
, 0, WInDev
[wDevID
].interface_name
, -1,
802 NULL
, 0 ) * sizeof(WCHAR
);
803 return MMSYSERR_NOERROR
;
806 /**************************************************************************
807 * widDevInterface [internal]
809 static DWORD
widDevInterface(UINT wDevID
, PWCHAR dwParam1
, DWORD dwParam2
)
811 if (dwParam2
>= MultiByteToWideChar(CP_ACP
, 0, WInDev
[wDevID
].interface_name
, -1,
812 NULL
, 0 ) * sizeof(WCHAR
))
814 MultiByteToWideChar(CP_ACP
, 0, WInDev
[wDevID
].interface_name
, -1,
815 dwParam1
, dwParam2
/ sizeof(WCHAR
));
816 return MMSYSERR_NOERROR
;
818 return MMSYSERR_INVALPARAM
;
821 /**************************************************************************
822 * widDsCreate [internal]
824 static DWORD
widDsCreate(UINT wDevID
, PIDSCDRIVER
* drv
)
826 TRACE("(%d,%p)\n",wDevID
,drv
);
828 /* the HAL isn't much better than the HEL if we can't do mmap() */
829 FIXME("DirectSoundCapture not implemented\n");
830 FIXME("The (slower) DirectSound HEL mode will be used instead.\n");
831 return MMSYSERR_NOTSUPPORTED
;
834 /**************************************************************************
835 * widDsDesc [internal]
837 static DWORD
widDsDesc(UINT wDevID
, PDSDRIVERDESC desc
)
839 memcpy(desc
, &(WInDev
[wDevID
].ds_desc
), sizeof(DSDRIVERDESC
));
840 return MMSYSERR_NOERROR
;
843 /**************************************************************************
844 * widMessage (WINEALSA.@)
846 DWORD WINAPI
ALSA_widMessage(UINT wDevID
, UINT wMsg
, DWORD dwUser
,
847 DWORD dwParam1
, DWORD dwParam2
)
849 TRACE("(%u, %s, %08X, %08X, %08X);\n",
850 wDevID
, ALSA_getMessage(wMsg
), dwUser
, dwParam1
, dwParam2
);
857 /* FIXME: Pretend this is supported */
859 case WIDM_OPEN
: return widOpen (wDevID
, (LPWAVEOPENDESC
)dwParam1
, dwParam2
);
860 case WIDM_CLOSE
: return widClose (wDevID
);
861 case WIDM_ADDBUFFER
: return widAddBuffer (wDevID
, (LPWAVEHDR
)dwParam1
, dwParam2
);
862 case WIDM_PREPARE
: return MMSYSERR_NOTSUPPORTED
;
863 case WIDM_UNPREPARE
: return MMSYSERR_NOTSUPPORTED
;
864 case WIDM_GETDEVCAPS
: return widGetDevCaps (wDevID
, (LPWAVEINCAPSW
)dwParam1
, dwParam2
);
865 case WIDM_GETNUMDEVS
: return widGetNumDevs ();
866 case WIDM_GETPOS
: return widGetPosition (wDevID
, (LPMMTIME
)dwParam1
, dwParam2
);
867 case WIDM_RESET
: return widReset (wDevID
);
868 case WIDM_START
: return widStart (wDevID
, (LPWAVEHDR
)dwParam1
, dwParam2
);
869 case WIDM_STOP
: return widStop (wDevID
, (LPWAVEHDR
)dwParam1
, dwParam2
);
870 case DRV_QUERYDEVICEINTERFACESIZE
: return widDevInterfaceSize (wDevID
, (LPDWORD
)dwParam1
);
871 case DRV_QUERYDEVICEINTERFACE
: return widDevInterface (wDevID
, (PWCHAR
)dwParam1
, dwParam2
);
872 case DRV_QUERYDSOUNDIFACE
: return widDsCreate (wDevID
, (PIDSCDRIVER
*)dwParam1
);
873 case DRV_QUERYDSOUNDDESC
: return widDsDesc (wDevID
, (PDSDRIVERDESC
)dwParam1
);
875 FIXME("unknown message %d!\n", wMsg
);
877 return MMSYSERR_NOTSUPPORTED
;
880 #else /* HAVE_ALSA */
882 /**************************************************************************
883 * widMessage (WINEALSA.@)
885 DWORD WINAPI
ALSA_widMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
886 DWORD dwParam1
, DWORD dwParam2
)
888 FIXME("(%u, %04X, %08X, %08X, %08X):stub\n", wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
889 return MMSYSERR_NOTENABLED
;
892 #endif /* HAVE_ALSA */