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, LPWAVEOUTCAPSW 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 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 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 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 */
393 FIXME("unknown message %d\n", msg);
399 /* just for not generating compilation warnings... should never be executed */
403 /**************************************************************************
406 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
409 snd_pcm_hw_params_t * hw_params;
410 snd_pcm_sw_params_t * sw_params;
411 snd_pcm_access_t access;
412 snd_pcm_format_t format;
414 unsigned int buffer_time = 500000;
415 unsigned int period_time = 10000;
416 snd_pcm_uframes_t buffer_size;
417 snd_pcm_uframes_t period_size;
423 snd_pcm_hw_params_alloca(&hw_params);
424 snd_pcm_sw_params_alloca(&sw_params);
426 /* JPW TODO - review this code */
427 TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
428 if (lpDesc == NULL) {
429 WARN("Invalid Parameter !\n");
430 return MMSYSERR_INVALPARAM;
432 if (wDevID >= ALSA_WidNumDevs) {
433 TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
434 return MMSYSERR_BADDEVICEID;
437 /* only PCM format is supported so far... */
438 if (!ALSA_supportedFormat(lpDesc->lpFormat)) {
439 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
440 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
441 lpDesc->lpFormat->nSamplesPerSec);
442 return WAVERR_BADFORMAT;
445 if (dwFlags & WAVE_FORMAT_QUERY) {
446 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
447 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
448 lpDesc->lpFormat->nSamplesPerSec);
449 return MMSYSERR_NOERROR;
452 wwi = &WInDev[wDevID];
454 if (wwi->pcm != NULL) {
455 WARN("already allocated\n");
456 return MMSYSERR_ALLOCATED;
459 if ((dwFlags & WAVE_DIRECTSOUND) && !(wwi->dwSupport & WAVECAPS_DIRECTSOUND))
460 /* not supported, ignore it */
461 dwFlags &= ~WAVE_DIRECTSOUND;
464 flags = SND_PCM_NONBLOCK;
466 if ( (err=snd_pcm_open(&pcm, wwi->pcmname, SND_PCM_STREAM_CAPTURE, flags)) < 0 )
468 ERR("Error open: %s\n", snd_strerror(err));
469 return MMSYSERR_NOTENABLED;
472 wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
474 memcpy(&wwi->waveDesc, lpDesc, sizeof(WAVEOPENDESC));
475 ALSA_copyFormat(lpDesc->lpFormat, &wwi->format);
477 if (wwi->format.Format.wBitsPerSample == 0) {
478 WARN("Resetting zeroed wBitsPerSample\n");
479 wwi->format.Format.wBitsPerSample = 8 *
480 (wwi->format.Format.nAvgBytesPerSec /
481 wwi->format.Format.nSamplesPerSec) /
482 wwi->format.Format.nChannels;
485 snd_pcm_hw_params_any(pcm, hw_params);
487 #define EXIT_ON_ERROR(f,e,txt) do \
490 if ( (err = (f) ) < 0) \
492 WARN(txt ": %s\n", snd_strerror(err)); \
493 snd_pcm_close(pcm); \
498 access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
499 if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
500 WARN("mmap not available. switching to standard write.\n");
501 access = SND_PCM_ACCESS_RW_INTERLEAVED;
502 EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
503 wwi->read = snd_pcm_readi;
506 wwi->read = snd_pcm_mmap_readi;
508 EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwi->format.Format.nChannels), WAVERR_BADFORMAT, "unable to set required channels");
510 if ((wwi->format.Format.wFormatTag == WAVE_FORMAT_PCM) ||
511 ((wwi->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
512 IsEqualGUID(&wwi->format.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) {
513 format = (wwi->format.Format.wBitsPerSample == 8) ? SND_PCM_FORMAT_U8 :
514 (wwi->format.Format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE :
515 (wwi->format.Format.wBitsPerSample == 24) ? SND_PCM_FORMAT_S24_LE :
516 (wwi->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_S32_LE : -1;
517 } else if ((wwi->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
518 IsEqualGUID(&wwi->format.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)){
519 format = (wwi->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_FLOAT_LE : -1;
520 } else if (wwi->format.Format.wFormatTag == WAVE_FORMAT_MULAW) {
521 FIXME("unimplemented format: WAVE_FORMAT_MULAW\n");
523 return WAVERR_BADFORMAT;
524 } else if (wwi->format.Format.wFormatTag == WAVE_FORMAT_ALAW) {
525 FIXME("unimplemented format: WAVE_FORMAT_ALAW\n");
527 return WAVERR_BADFORMAT;
528 } else if (wwi->format.Format.wFormatTag == WAVE_FORMAT_ADPCM) {
529 FIXME("unimplemented format: WAVE_FORMAT_ADPCM\n");
531 return WAVERR_BADFORMAT;
533 ERR("invalid format: %0x04x\n", wwi->format.Format.wFormatTag);
535 return WAVERR_BADFORMAT;
538 EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), WAVERR_BADFORMAT, "unable to set required format");
540 rate = wwi->format.Format.nSamplesPerSec;
542 err = snd_pcm_hw_params_set_rate_near(pcm, hw_params, &rate, &dir);
544 WARN("Rate %d Hz not available for playback: %s\n", wwi->format.Format.nSamplesPerSec, snd_strerror(rate));
546 return WAVERR_BADFORMAT;
548 if (!ALSA_NearMatch(rate, wwi->format.Format.nSamplesPerSec)) {
549 WARN("Rate doesn't match (requested %d Hz, got %d Hz)\n", wwi->format.Format.nSamplesPerSec, rate);
551 return WAVERR_BADFORMAT;
555 EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, &buffer_time, &dir), MMSYSERR_INVALPARAM, "unable to set buffer time");
557 EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm, hw_params, &period_time, &dir), MMSYSERR_INVALPARAM, "unable to set period time");
559 EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
562 err = snd_pcm_hw_params_get_period_size(hw_params, &period_size, &dir);
563 err = snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
565 snd_pcm_sw_params_current(pcm, sw_params);
566 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");
567 EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence size");
568 EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
569 EXIT_ON_ERROR( snd_pcm_sw_params_set_xfer_align(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set xfer align");
570 EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
571 EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
574 snd_pcm_prepare(pcm);
577 ALSA_TraceParameters(hw_params, sw_params, FALSE);
579 /* now, we can save all required data for later use... */
580 if ( wwi->hw_params )
581 snd_pcm_hw_params_free(wwi->hw_params);
582 snd_pcm_hw_params_malloc(&(wwi->hw_params));
583 snd_pcm_hw_params_copy(wwi->hw_params, hw_params);
585 wwi->dwBufferSize = snd_pcm_frames_to_bytes(pcm, buffer_size);
586 wwi->lpQueuePtr = wwi->lpPlayPtr = wwi->lpLoopPtr = NULL;
589 ALSA_InitRingMessage(&wwi->msgRing);
591 wwi->dwPeriodSize = period_size;
592 /*if (wwi->dwFragmentSize % wwi->format.Format.nBlockAlign)
593 ERR("Fragment doesn't contain an integral number of data blocks\n");
595 TRACE("dwPeriodSize=%u\n", wwi->dwPeriodSize);
596 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
597 wwi->format.Format.wBitsPerSample, wwi->format.Format.nAvgBytesPerSec,
598 wwi->format.Format.nSamplesPerSec, wwi->format.Format.nChannels,
599 wwi->format.Format.nBlockAlign);
601 if (!(dwFlags & WAVE_DIRECTSOUND)) {
602 wwi->hStartUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
603 wwi->hThread = CreateThread(NULL, 0, widRecorder, (LPVOID)(DWORD)wDevID, 0, &(wwi->dwThreadID));
605 SetThreadPriority(wwi->hThread, THREAD_PRIORITY_TIME_CRITICAL);
606 WaitForSingleObject(wwi->hStartUpEvent, INFINITE);
607 CloseHandle(wwi->hStartUpEvent);
609 wwi->hThread = INVALID_HANDLE_VALUE;
612 wwi->hStartUpEvent = INVALID_HANDLE_VALUE;
614 return widNotifyClient(wwi, WIM_OPEN, 0L, 0L);
618 /**************************************************************************
619 * widClose [internal]
621 static DWORD widClose(WORD wDevID)
623 DWORD ret = MMSYSERR_NOERROR;
626 TRACE("(%u);\n", wDevID);
628 if (wDevID >= ALSA_WidNumDevs) {
629 TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
630 return MMSYSERR_BADDEVICEID;
633 if (WInDev[wDevID].pcm == NULL) {
634 WARN("Requested to close already closed device %d!\n", wDevID);
635 return MMSYSERR_BADDEVICEID;
638 wwi = &WInDev[wDevID];
639 if (wwi->lpQueuePtr) {
640 WARN("buffers still playing !\n");
641 ret = WAVERR_STILLPLAYING;
643 if (wwi->hThread != INVALID_HANDLE_VALUE) {
644 ALSA_AddRingMessage(&wwi->msgRing, WINE_WM_CLOSING, 0, TRUE);
646 ALSA_DestroyRingMessage(&wwi->msgRing);
648 snd_pcm_hw_params_free(wwi->hw_params);
649 wwi->hw_params = NULL;
651 snd_pcm_close(wwi->pcm);
654 ret = widNotifyClient(wwi, WIM_CLOSE, 0L, 0L);
660 /**************************************************************************
661 * widAddBuffer [internal]
664 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
666 TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
668 /* first, do the sanity checks... */
669 if (wDevID >= ALSA_WidNumDevs) {
670 TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
671 return MMSYSERR_BADDEVICEID;
674 if (WInDev[wDevID].pcm == NULL) {
675 WARN("Requested to add buffer to already closed device %d!\n", wDevID);
676 return MMSYSERR_BADDEVICEID;
679 if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
680 return WAVERR_UNPREPARED;
682 if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
683 return WAVERR_STILLPLAYING;
685 lpWaveHdr->dwFlags &= ~WHDR_DONE;
686 lpWaveHdr->dwFlags |= WHDR_INQUEUE;
687 lpWaveHdr->lpNext = 0;
689 ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
691 return MMSYSERR_NOERROR;
694 /**************************************************************************
695 * widStart [internal]
698 static DWORD widStart(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
700 TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
702 /* first, do the sanity checks... */
703 if (wDevID >= ALSA_WidNumDevs) {
704 TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
705 return MMSYSERR_BADDEVICEID;
708 if (WInDev[wDevID].pcm == NULL) {
709 WARN("Requested to start closed device %d!\n", wDevID);
710 return MMSYSERR_BADDEVICEID;
713 ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_STARTING, 0, TRUE);
715 return MMSYSERR_NOERROR;
718 /**************************************************************************
722 static DWORD widStop(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
724 TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
726 /* first, do the sanity checks... */
727 if (wDevID >= ALSA_WidNumDevs) {
728 TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
729 return MMSYSERR_BADDEVICEID;
732 if (WInDev[wDevID].pcm == NULL) {
733 WARN("Requested to stop closed device %d!\n", wDevID);
734 return MMSYSERR_BADDEVICEID;
737 ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_STOPPING, 0, TRUE);
739 return MMSYSERR_NOERROR;
742 /**************************************************************************
743 * widReset [internal]
745 static DWORD widReset(WORD wDevID)
747 TRACE("(%u);\n", wDevID);
748 if (wDevID >= ALSA_WidNumDevs) {
749 TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
750 return MMSYSERR_BADDEVICEID;
753 if (WInDev[wDevID].pcm == NULL) {
754 WARN("Requested to reset closed device %d!\n", wDevID);
755 return MMSYSERR_BADDEVICEID;
758 ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
759 return MMSYSERR_NOERROR;
762 /**************************************************************************
763 * widGetPosition [internal]
765 static DWORD widGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
769 TRACE("(%u, %p, %u);\n", wDevID, lpTime, uSize);
771 if (wDevID >= ALSA_WidNumDevs) {
772 TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
773 return MMSYSERR_BADDEVICEID;
776 if (WInDev[wDevID].state == WINE_WS_CLOSED) {
777 WARN("Requested position of closed device %d!\n", wDevID);
778 return MMSYSERR_BADDEVICEID;
781 if (lpTime == NULL) {
782 WARN("invalid parameter: lpTime = NULL\n");
783 return MMSYSERR_INVALPARAM;
786 wwi = &WInDev[wDevID];
787 ALSA_AddRingMessage(&wwi->msgRing, WINE_WM_UPDATE, 0, TRUE);
789 return ALSA_bytes_to_mmtime(lpTime, wwi->dwTotalRecorded, &wwi->format);
792 /**************************************************************************
793 * widGetNumDevs [internal]
795 static DWORD widGetNumDevs(void)
797 return ALSA_WidNumDevs;
800 /**************************************************************************
801 * widDevInterfaceSize [internal]
803 static DWORD widDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
805 TRACE("(%u, %p)\n", wDevID, dwParam1);
807 *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
808 NULL, 0 ) * sizeof(WCHAR);
809 return MMSYSERR_NOERROR;
812 /**************************************************************************
813 * widDevInterface [internal]
815 static DWORD widDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
817 if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
818 NULL, 0 ) * sizeof(WCHAR))
820 MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
821 dwParam1, dwParam2 / sizeof(WCHAR));
822 return MMSYSERR_NOERROR;
824 return MMSYSERR_INVALPARAM;
827 /**************************************************************************
828 * widDsCreate [internal]
830 static DWORD widDsCreate(UINT wDevID, PIDSCDRIVER* drv)
832 TRACE("(%d,%p)\n",wDevID,drv);
834 /* the HAL isn't much better than the HEL if we can't do mmap() */
835 FIXME("DirectSoundCapture not implemented\n");
836 FIXME("The (slower) DirectSound HEL mode will be used instead.\n");
837 return MMSYSERR_NOTSUPPORTED;
840 /**************************************************************************
841 * widDsDesc [internal]
843 static DWORD widDsDesc(UINT wDevID, PDSDRIVERDESC desc)
845 memcpy(desc, &(WInDev[wDevID].ds_desc), sizeof(DSDRIVERDESC));
846 return MMSYSERR_NOERROR;
849 /**************************************************************************
850 * widMessage (WINEALSA.@)
852 DWORD WINAPI ALSA_widMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
853 DWORD dwParam1, DWORD dwParam2)
855 TRACE("(%u, %s, %08X, %08X, %08X);\n",
856 wDevID, ALSA_getMessage(wMsg), dwUser, dwParam1, dwParam2);
863 /* FIXME: Pretend this is supported */
865 case WIDM_OPEN: return widOpen (wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
866 case WIDM_CLOSE: return widClose (wDevID);
867 case WIDM_ADDBUFFER: return widAddBuffer (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
868 case WIDM_PREPARE: return MMSYSERR_NOTSUPPORTED;
869 case WIDM_UNPREPARE: return MMSYSERR_NOTSUPPORTED;
870 case WIDM_GETDEVCAPS: return widGetDevCaps (wDevID, (LPWAVEOUTCAPSW)dwParam1, dwParam2);
871 case WIDM_GETNUMDEVS: return widGetNumDevs ();
872 case WIDM_GETPOS: return widGetPosition (wDevID, (LPMMTIME)dwParam1, dwParam2);
873 case WIDM_RESET: return widReset (wDevID);
874 case WIDM_START: return widStart (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
875 case WIDM_STOP: return widStop (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
876 case DRV_QUERYDEVICEINTERFACESIZE: return widDevInterfaceSize (wDevID, (LPDWORD)dwParam1);
877 case DRV_QUERYDEVICEINTERFACE: return widDevInterface (wDevID, (PWCHAR)dwParam1, dwParam2);
878 case DRV_QUERYDSOUNDIFACE: return widDsCreate (wDevID, (PIDSCDRIVER*)dwParam1);
879 case DRV_QUERYDSOUNDDESC: return widDsDesc (wDevID, (PDSDRIVERDESC)dwParam1);
881 FIXME("unknown message %d!\n", wMsg);
883 return MMSYSERR_NOTSUPPORTED;
886 #else /* HAVE_ALSA */
888 /**************************************************************************
889 * widMessage (WINEALSA.@)
891 DWORD WINAPI ALSA_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
892 DWORD dwParam1, DWORD dwParam2)
894 FIXME("(%u, %04X, %08X, %08X, %08X):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
895 return MMSYSERR_NOTENABLED;
898 #endif /* HAVE_ALSA */