msxml3: Add error code defines.
[wine] / dlls / winealsa.drv / waveout.c
1 /*
2  * Sample Wine Driver for Advanced Linux Sound System (ALSA)
3  *      Based on version <final> of the ALSA API
4  *
5  * Copyright    2002 Eric Pouech
6  *              2002 Marco Pietrobono
7  *              2003 Christian Costa : WaveIn support
8  *              2006-2007 Maarten Lankhorst
9  *
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.
14  *
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.
19  *
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
23  */
24
25 /*======================================================================*
26  *                  Low level WAVE OUT implementation                   *
27  *======================================================================*/
28
29 #include "config.h"
30 #include "wine/port.h"
31
32 #include <stdlib.h>
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <string.h>
36 #ifdef HAVE_UNISTD_H
37 # include <unistd.h>
38 #endif
39 #include <errno.h>
40 #include <limits.h>
41 #include <fcntl.h>
42 #ifdef HAVE_SYS_IOCTL_H
43 # include <sys/ioctl.h>
44 #endif
45 #ifdef HAVE_SYS_MMAN_H
46 # include <sys/mman.h>
47 #endif
48 #include "windef.h"
49 #include "winbase.h"
50 #include "wingdi.h"
51 #include "winuser.h"
52 #include "winnls.h"
53 #include "mmddk.h"
54
55 #include "alsa.h"
56
57 #include "wine/library.h"
58 #include "wine/unicode.h"
59 #include "wine/debug.h"
60
61 WINE_DEFAULT_DEBUG_CHANNEL(wave);
62
63 #ifdef HAVE_ALSA
64
65 WINE_WAVEDEV    *WOutDev;
66 DWORD            ALSA_WodNumMallocedDevs;
67 DWORD            ALSA_WodNumDevs;
68
69 /**************************************************************************
70  *                      wodNotifyClient                 [internal]
71  */
72 static DWORD wodNotifyClient(WINE_WAVEDEV* wwo, WORD wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
73 {
74     TRACE("wMsg = 0x%04x dwParm1 = %lx dwParam2 = %lx\n", wMsg, dwParam1, dwParam2);
75
76     switch (wMsg) {
77     case WOM_OPEN:
78     case WOM_CLOSE:
79     case WOM_DONE:
80         if (wwo->wFlags != DCB_NULL &&
81             !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, (HDRVR)wwo->waveDesc.hWave,
82                             wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
83             WARN("can't notify client !\n");
84             return MMSYSERR_ERROR;
85         }
86         break;
87     default:
88         FIXME("Unknown callback message %u\n", wMsg);
89         return MMSYSERR_INVALPARAM;
90     }
91     return MMSYSERR_NOERROR;
92 }
93
94 /**************************************************************************
95  *                              wodUpdatePlayedTotal    [internal]
96  *
97  */
98 static BOOL wodUpdatePlayedTotal(WINE_WAVEDEV* wwo, snd_pcm_status_t* ps)
99 {
100     snd_pcm_sframes_t delay;
101     snd_pcm_sframes_t avail;
102     snd_pcm_uframes_t buf_size = 0;
103     snd_pcm_state_t state;
104
105     state = snd_pcm_state(wwo->pcm);
106     avail = snd_pcm_avail_update(wwo->pcm);
107     snd_pcm_hw_params_get_buffer_size(wwo->hw_params, &buf_size);
108     delay = buf_size - avail;
109
110     if (state != SND_PCM_STATE_RUNNING && state != SND_PCM_STATE_PREPARED)
111     {
112         WARN("Unexpected state (%d) while updating Total Played, resetting\n", state);
113         wine_snd_pcm_recover(wwo->pcm, -EPIPE, 0);
114         delay=0;
115     }
116
117     /* A delay < 0 indicates an underrun; for our purposes that's 0.  */
118     if (delay < 0)
119     {
120         WARN("Unexpected delay (%ld) while updating Total Played, resetting\n", delay);
121         delay=0;
122     }
123
124     InterlockedExchange((LONG*)&wwo->dwPlayedTotal, wwo->dwWrittenTotal - snd_pcm_frames_to_bytes(wwo->pcm, delay));
125     return TRUE;
126 }
127
128 /**************************************************************************
129  *                              wodPlayer_BeginWaveHdr          [internal]
130  *
131  * Makes the specified lpWaveHdr the currently playing wave header.
132  * If the specified wave header is a begin loop and we're not already in
133  * a loop, setup the loop.
134  */
135 static void wodPlayer_BeginWaveHdr(WINE_WAVEDEV* wwo, LPWAVEHDR lpWaveHdr)
136 {
137     wwo->lpPlayPtr = lpWaveHdr;
138
139     if (!lpWaveHdr) return;
140
141     if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
142         if (wwo->lpLoopPtr) {
143             WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
144         } else {
145             TRACE("Starting loop (%dx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
146             wwo->lpLoopPtr = lpWaveHdr;
147             /* Windows does not touch WAVEHDR.dwLoops,
148              * so we need to make an internal copy */
149             wwo->dwLoops = lpWaveHdr->dwLoops;
150         }
151     }
152     wwo->dwPartialOffset = 0;
153 }
154
155 /**************************************************************************
156  *                              wodPlayer_PlayPtrNext           [internal]
157  *
158  * Advance the play pointer to the next waveheader, looping if required.
159  */
160 static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEDEV* wwo)
161 {
162     LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
163
164     wwo->dwPartialOffset = 0;
165     if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
166         /* We're at the end of a loop, loop if required */
167         if (--wwo->dwLoops > 0) {
168             wwo->lpPlayPtr = wwo->lpLoopPtr;
169         } else {
170             /* Handle overlapping loops correctly */
171             if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
172                 FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
173                 /* shall we consider the END flag for the closing loop or for
174                  * the opening one or for both ???
175                  * code assumes for closing loop only
176                  */
177             } else {
178                 lpWaveHdr = lpWaveHdr->lpNext;
179             }
180             wwo->lpLoopPtr = NULL;
181             wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
182         }
183     } else {
184         /* We're not in a loop.  Advance to the next wave header */
185         wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
186     }
187
188     return lpWaveHdr;
189 }
190
191 /**************************************************************************
192  *                           wodPlayer_DSPWait                  [internal]
193  * Returns the number of milliseconds to wait for the DSP buffer to play a
194  * period
195  */
196 static DWORD wodPlayer_DSPWait(const WINE_WAVEDEV *wwo)
197 {
198     /* time for one period to be played */
199     unsigned int val=0;
200     int dir=0;
201     int err=0;
202     err = snd_pcm_hw_params_get_period_time(wwo->hw_params, &val, &dir);
203     return val / 1000;
204 }
205
206 /**************************************************************************
207  *                           wodPlayer_NotifyWait               [internal]
208  * Returns the number of milliseconds to wait before attempting to notify
209  * completion of the specified wavehdr.
210  * This is based on the number of bytes remaining to be written in the
211  * wave.
212  */
213 static DWORD wodPlayer_NotifyWait(const WINE_WAVEDEV* wwo, LPWAVEHDR lpWaveHdr)
214 {
215     DWORD dwMillis;
216
217     if (lpWaveHdr->reserved < wwo->dwPlayedTotal) {
218         dwMillis = 1;
219     } else {
220         dwMillis = (lpWaveHdr->reserved - wwo->dwPlayedTotal) * 1000 / wwo->format.Format.nAvgBytesPerSec;
221         if (!dwMillis) dwMillis = 1;
222     }
223
224     return dwMillis;
225 }
226
227
228 /**************************************************************************
229  *                           wodPlayer_WriteMaxFrags            [internal]
230  * Writes the maximum number of frames possible to the DSP and returns
231  * the number of frames written.
232  */
233 static int wodPlayer_WriteMaxFrags(WINE_WAVEDEV* wwo, DWORD* frames)
234 {
235     /* Only attempt to write to free frames */
236     LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
237     DWORD dwLength = snd_pcm_bytes_to_frames(wwo->pcm, lpWaveHdr->dwBufferLength - wwo->dwPartialOffset);
238     int toWrite = min(dwLength, *frames);
239     int written;
240
241     TRACE("Writing wavehdr %p.%u[%u]\n", lpWaveHdr, wwo->dwPartialOffset, lpWaveHdr->dwBufferLength);
242
243     if (toWrite > 0) {
244         written = (wwo->write)(wwo->pcm, lpWaveHdr->lpData + wwo->dwPartialOffset, toWrite);
245         if ( written < 0) {
246             /* XRUN occurred. let's try to recover */
247             wine_snd_pcm_recover(wwo->pcm, written, 0);
248             written = (wwo->write)(wwo->pcm, lpWaveHdr->lpData + wwo->dwPartialOffset, toWrite);
249         }
250         if (written <= 0) {
251             /* still in error */
252             ERR("Error in writing wavehdr. Reason: %s\n", snd_strerror(written));
253             return written;
254         }
255     } else
256         written = 0;
257
258     wwo->dwPartialOffset += snd_pcm_frames_to_bytes(wwo->pcm, written);
259     if (wwo->dwPartialOffset + wwo->format.Format.nBlockAlign - 1 >= lpWaveHdr->dwBufferLength) {
260         /* this will be used to check if the given wave header has been fully played or not... */
261         wwo->dwPartialOffset = lpWaveHdr->dwBufferLength;
262         /* If we wrote all current wavehdr, skip to the next one */
263         wodPlayer_PlayPtrNext(wwo);
264     }
265     *frames -= written;
266     wwo->dwWrittenTotal += snd_pcm_frames_to_bytes(wwo->pcm, written);
267     TRACE("dwWrittenTotal=%u\n", wwo->dwWrittenTotal);
268
269     return written;
270 }
271
272
273 /**************************************************************************
274  *                              wodPlayer_NotifyCompletions     [internal]
275  *
276  * Notifies and remove from queue all wavehdrs which have been played to
277  * the speaker (ie. they have cleared the ALSA buffer).  If force is true,
278  * we notify all wavehdrs and remove them all from the queue even if they
279  * are unplayed or part of a loop.
280  */
281 static DWORD wodPlayer_NotifyCompletions(WINE_WAVEDEV* wwo, BOOL force)
282 {
283     LPWAVEHDR           lpWaveHdr;
284
285     /* Start from lpQueuePtr and keep notifying until:
286      * - we hit an unwritten wavehdr
287      * - we hit the beginning of a running loop
288      * - we hit a wavehdr which hasn't finished playing
289      */
290     for (;;)
291     {
292         lpWaveHdr = wwo->lpQueuePtr;
293         if (!lpWaveHdr) {TRACE("Empty queue\n"); break;}
294         if (!force)
295         {
296             snd_pcm_uframes_t frames;
297             snd_pcm_hw_params_get_period_size(wwo->hw_params, &frames, NULL);
298
299             if (lpWaveHdr == wwo->lpPlayPtr) {TRACE("play %p\n", lpWaveHdr); break;}
300             if (lpWaveHdr == wwo->lpLoopPtr) {TRACE("loop %p\n", lpWaveHdr); break;}
301             if (lpWaveHdr->reserved > wwo->dwPlayedTotal + frames) {TRACE("still playing %p (%lu/%u)\n", lpWaveHdr, lpWaveHdr->reserved, wwo->dwPlayedTotal);break;}
302         }
303         wwo->dwPlayedTotal += lpWaveHdr->reserved - wwo->dwPlayedTotal;
304         wwo->lpQueuePtr = lpWaveHdr->lpNext;
305
306         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
307         lpWaveHdr->dwFlags |= WHDR_DONE;
308
309         wodNotifyClient(wwo, WOM_DONE, (DWORD_PTR)lpWaveHdr, 0);
310     }
311     return  (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != wwo->lpLoopPtr) ?
312         wodPlayer_NotifyWait(wwo, lpWaveHdr) : INFINITE;
313 }
314
315
316 /**************************************************************************
317  *                              wodPlayer_Reset                 [internal]
318  *
319  * wodPlayer helper. Resets current output stream.
320  */
321 static  void    wodPlayer_Reset(WINE_WAVEDEV* wwo, BOOL reset)
322 {
323     int                         err;
324     TRACE("(%p)\n", wwo);
325
326     wodUpdatePlayedTotal(wwo, NULL);
327     /* updates current notify list */
328     wodPlayer_NotifyCompletions(wwo, FALSE);
329
330     if ( (err = snd_pcm_drop(wwo->pcm)) < 0) {
331         FIXME("flush: %s\n", snd_strerror(err));
332         wwo->hThread = 0;
333         wwo->state = WINE_WS_STOPPED;
334         ExitThread(-1);
335     }
336     if ( (err = snd_pcm_prepare(wwo->pcm)) < 0 )
337         ERR("pcm prepare failed: %s\n", snd_strerror(err));
338
339     if (reset) {
340         enum win_wm_message     msg;
341         DWORD_PTR               param;
342         HANDLE                  ev;
343
344         /* remove any buffer */
345         wodPlayer_NotifyCompletions(wwo, TRUE);
346
347         wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
348         wwo->state = WINE_WS_STOPPED;
349         wwo->dwPlayedTotal = wwo->dwWrittenTotal = 0;
350         /* Clear partial wavehdr */
351         wwo->dwPartialOffset = 0;
352
353         /* remove any existing message in the ring */
354         EnterCriticalSection(&wwo->msgRing.msg_crst);
355         /* return all pending headers in queue */
356         while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev))
357         {
358             if (msg != WINE_WM_HEADER)
359             {
360                 FIXME("shouldn't have headers left\n");
361                 SetEvent(ev);
362                 continue;
363             }
364             ((LPWAVEHDR)param)->dwFlags &= ~WHDR_INQUEUE;
365             ((LPWAVEHDR)param)->dwFlags |= WHDR_DONE;
366
367                 wodNotifyClient(wwo, WOM_DONE, param, 0);
368         }
369         ALSA_ResetRingMessage(&wwo->msgRing);
370         LeaveCriticalSection(&wwo->msgRing.msg_crst);
371     } else {
372         if (wwo->lpLoopPtr) {
373             /* complicated case, not handled yet (could imply modifying the loop counter */
374             FIXME("Pausing while in loop isn't correctly handled yet, expect strange results\n");
375             wwo->lpPlayPtr = wwo->lpLoopPtr;
376             wwo->dwPartialOffset = 0;
377             wwo->dwWrittenTotal = wwo->dwPlayedTotal; /* this is wrong !!! */
378         } else {
379             LPWAVEHDR   ptr;
380             DWORD       sz = wwo->dwPartialOffset;
381
382             /* reset all the data as if we had written only up to lpPlayedTotal bytes */
383             /* compute the max size playable from lpQueuePtr */
384             for (ptr = wwo->lpQueuePtr; ptr != wwo->lpPlayPtr; ptr = ptr->lpNext) {
385                 sz += ptr->dwBufferLength;
386             }
387             /* because the reset lpPlayPtr will be lpQueuePtr */
388             if (wwo->dwWrittenTotal > wwo->dwPlayedTotal + sz) ERR("grin\n");
389             wwo->dwPartialOffset = sz - (wwo->dwWrittenTotal - wwo->dwPlayedTotal);
390             wwo->dwWrittenTotal = wwo->dwPlayedTotal;
391             wwo->lpPlayPtr = wwo->lpQueuePtr;
392         }
393         wwo->state = WINE_WS_PAUSED;
394     }
395 }
396
397 /**************************************************************************
398  *                    wodPlayer_ProcessMessages                 [internal]
399  */
400 static void wodPlayer_ProcessMessages(WINE_WAVEDEV* wwo)
401 {
402     LPWAVEHDR           lpWaveHdr;
403     enum win_wm_message msg;
404     DWORD_PTR           param;
405     HANDLE              ev;
406     int                 err;
407
408     while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev)) {
409      TRACE("Received %s %lx\n", ALSA_getCmdString(msg), param);
410
411         switch (msg) {
412         case WINE_WM_PAUSING:
413             if ( snd_pcm_state(wwo->pcm) == SND_PCM_STATE_RUNNING )
414              {
415                 if ( snd_pcm_hw_params_can_pause(wwo->hw_params) )
416                 {
417                     err = snd_pcm_pause(wwo->pcm, 1);
418                     if ( err < 0 )
419                         ERR("pcm_pause failed: %s\n", snd_strerror(err));
420                     wwo->state = WINE_WS_PAUSED;
421                 }
422                 else
423                 {
424                     wodPlayer_Reset(wwo,FALSE);
425                 }
426              }
427             SetEvent(ev);
428             break;
429         case WINE_WM_RESTARTING:
430             if (wwo->state == WINE_WS_PAUSED)
431             {
432                 if ( snd_pcm_state(wwo->pcm) == SND_PCM_STATE_PAUSED )
433                  {
434                     err = snd_pcm_pause(wwo->pcm, 0);
435                     if ( err < 0 )
436                         ERR("pcm_pause failed: %s\n", snd_strerror(err));
437                  }
438                 wwo->state = WINE_WS_PLAYING;
439             }
440             SetEvent(ev);
441             break;
442         case WINE_WM_HEADER:
443             lpWaveHdr = (LPWAVEHDR)param;
444
445             /* insert buffer at the end of queue */
446             {
447                 LPWAVEHDR*      wh;
448                 for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
449                 *wh = lpWaveHdr;
450             }
451             if (!wwo->lpPlayPtr)
452                 wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
453             if (wwo->state == WINE_WS_STOPPED)
454                 wwo->state = WINE_WS_PLAYING;
455             break;
456         case WINE_WM_RESETTING:
457             wodPlayer_Reset(wwo,TRUE);
458             SetEvent(ev);
459             break;
460         case WINE_WM_BREAKLOOP:
461             if (wwo->state == WINE_WS_PLAYING && wwo->lpLoopPtr != NULL) {
462                 /* ensure exit at end of current loop */
463                 wwo->dwLoops = 1;
464             }
465             SetEvent(ev);
466             break;
467         case WINE_WM_CLOSING:
468             /* sanity check: this should not happen since the device must have been reset before */
469             if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
470             wwo->hThread = 0;
471             wwo->state = WINE_WS_CLOSED;
472             SetEvent(ev);
473             ExitThread(0);
474             /* shouldn't go here */
475         default:
476             FIXME("unknown message %d\n", msg);
477             break;
478         }
479     }
480 }
481
482 /**************************************************************************
483  *                           wodPlayer_FeedDSP                  [internal]
484  * Feed as much sound data as we can into the DSP and return the number of
485  * milliseconds before it will be necessary to feed the DSP again.
486  */
487 static DWORD wodPlayer_FeedDSP(WINE_WAVEDEV* wwo)
488 {
489     DWORD               availInQ;
490
491     wodUpdatePlayedTotal(wwo, NULL);
492     availInQ = snd_pcm_avail_update(wwo->pcm);
493
494     /* no more room... no need to try to feed */
495     if (availInQ > 0) {
496         /* Feed from partial wavehdr */
497         if (wwo->lpPlayPtr && wwo->dwPartialOffset != 0) {
498             wodPlayer_WriteMaxFrags(wwo, &availInQ);
499         }
500
501         /* Feed wavehdrs until we run out of wavehdrs or DSP space */
502         if (wwo->dwPartialOffset == 0 && wwo->lpPlayPtr) {
503             do {
504                 TRACE("Setting time to elapse for %p to %u\n",
505                       wwo->lpPlayPtr, wwo->dwWrittenTotal + wwo->lpPlayPtr->dwBufferLength);
506                 /* note the value that dwPlayedTotal will return when this wave finishes playing */
507                 wwo->lpPlayPtr->reserved = wwo->dwWrittenTotal + wwo->lpPlayPtr->dwBufferLength;
508             } while (wodPlayer_WriteMaxFrags(wwo, &availInQ) && wwo->lpPlayPtr && availInQ > 0);
509         }
510     }
511
512     return wodPlayer_DSPWait(wwo);
513 }
514
515 /**************************************************************************
516  *                              wodPlayer                       [internal]
517  */
518 static  DWORD   CALLBACK        wodPlayer(LPVOID pmt)
519 {
520     WORD          uDevID = (DWORD_PTR)pmt;
521     WINE_WAVEDEV* wwo = &WOutDev[uDevID];
522     DWORD         dwNextFeedTime = INFINITE;   /* Time before DSP needs feeding */
523     DWORD         dwNextNotifyTime = INFINITE; /* Time before next wave completion */
524     DWORD         dwSleepTime;
525
526     wwo->state = WINE_WS_STOPPED;
527     SetEvent(wwo->hStartUpEvent);
528
529     for (;;) {
530         /** Wait for the shortest time before an action is required.  If there
531          *  are no pending actions, wait forever for a command.
532          */
533         dwSleepTime = min(dwNextFeedTime, dwNextNotifyTime);
534         TRACE("waiting %ums (%u,%u)\n", dwSleepTime, dwNextFeedTime, dwNextNotifyTime);
535         ALSA_WaitRingMessage(&wwo->msgRing, dwSleepTime);
536         wodPlayer_ProcessMessages(wwo);
537         if (wwo->state == WINE_WS_PLAYING) {
538             dwNextFeedTime = wodPlayer_FeedDSP(wwo);
539             dwNextNotifyTime = wodPlayer_NotifyCompletions(wwo, FALSE);
540             if (dwNextFeedTime == INFINITE) {
541                 /* FeedDSP ran out of data, but before giving up, */
542                 /* check that a notification didn't give us more */
543                 wodPlayer_ProcessMessages(wwo);
544                 if (wwo->lpPlayPtr) {
545                     TRACE("recovering\n");
546                     dwNextFeedTime = wodPlayer_FeedDSP(wwo);
547                 }
548             }
549         } else {
550             dwNextFeedTime = dwNextNotifyTime = INFINITE;
551         }
552     }
553     return 0;
554 }
555
556 /**************************************************************************
557  *                      wodGetDevCaps                           [internal]
558  */
559 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSW lpCaps, DWORD dwSize)
560 {
561     TRACE("(%u, %p, %u);\n", wDevID, lpCaps, dwSize);
562
563     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
564
565     if (wDevID >= ALSA_WodNumDevs) {
566         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
567         return MMSYSERR_BADDEVICEID;
568     }
569
570     memcpy(lpCaps, &WOutDev[wDevID].outcaps, min(dwSize, sizeof(*lpCaps)));
571     return MMSYSERR_NOERROR;
572 }
573
574 /**************************************************************************
575  *                              wodOpen                         [internal]
576  */
577 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
578 {
579     WINE_WAVEDEV*               wwo;
580     snd_pcm_t *                 pcm = NULL;
581     snd_hctl_t *                hctl = NULL;
582     snd_pcm_hw_params_t *       hw_params = NULL;
583     snd_pcm_sw_params_t *       sw_params;
584     snd_pcm_access_t            access;
585     snd_pcm_format_t            format = -1;
586     unsigned int                rate;
587     unsigned int                buffer_time = 120000;
588     unsigned int                period_time = 22000;
589     snd_pcm_uframes_t           buffer_size;
590     snd_pcm_uframes_t           period_size;
591     int                         flags;
592     int                         err=0;
593     int                         dir=0;
594     DWORD                       retcode = 0;
595
596     TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
597     if (lpDesc == NULL) {
598         WARN("Invalid Parameter !\n");
599         return MMSYSERR_INVALPARAM;
600     }
601     if (wDevID >= ALSA_WodNumDevs) {
602         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
603         return MMSYSERR_BADDEVICEID;
604     }
605
606     /* only PCM format is supported so far... */
607     if (!ALSA_supportedFormat(lpDesc->lpFormat)) {
608         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
609              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
610              lpDesc->lpFormat->nSamplesPerSec);
611         return WAVERR_BADFORMAT;
612     }
613
614     if (dwFlags & WAVE_FORMAT_QUERY) {
615         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
616              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
617              lpDesc->lpFormat->nSamplesPerSec);
618         return MMSYSERR_NOERROR;
619     }
620
621     wwo = &WOutDev[wDevID];
622
623     if (wwo->pcm != NULL) {
624         WARN("%d already allocated\n", wDevID);
625         return MMSYSERR_ALLOCATED;
626     }
627
628     if (dwFlags & WAVE_DIRECTSOUND)
629         FIXME("Why are we called with DirectSound flag? It doesn't use MMSYSTEM any more\n");
630         /* not supported, ignore it */
631     dwFlags &= ~WAVE_DIRECTSOUND;
632
633     flags = SND_PCM_NONBLOCK;
634
635     if ( (err = snd_pcm_open(&pcm, wwo->pcmname, SND_PCM_STREAM_PLAYBACK, flags)) < 0)
636     {
637         ERR("Error open: %s\n", snd_strerror(err));
638         return MMSYSERR_NOTENABLED;
639     }
640
641     if (wwo->ctlname)
642     {
643         err = snd_hctl_open(&hctl, wwo->ctlname, 0);
644         if (err >= 0)
645         {
646             snd_hctl_load(hctl);
647         }
648         else
649         {
650             WARN("Could not open hctl for [%s]: %s\n", wwo->ctlname, snd_strerror(err));
651             hctl = NULL;
652         }
653     }
654
655     wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
656
657     wwo->waveDesc = *lpDesc;
658     ALSA_copyFormat(lpDesc->lpFormat, &wwo->format);
659
660     TRACE("Requested this format: %dx%dx%d %s\n",
661           wwo->format.Format.nSamplesPerSec,
662           wwo->format.Format.wBitsPerSample,
663           wwo->format.Format.nChannels,
664           ALSA_getFormat(wwo->format.Format.wFormatTag));
665
666     if (wwo->format.Format.wBitsPerSample == 0) {
667         WARN("Resetting zeroed wBitsPerSample\n");
668         wwo->format.Format.wBitsPerSample = 8 *
669             (wwo->format.Format.nAvgBytesPerSec /
670              wwo->format.Format.nSamplesPerSec) /
671             wwo->format.Format.nChannels;
672     }
673
674 #define EXIT_ON_ERROR(f,e,txt) do \
675 { \
676     int err; \
677     if ( (err = (f) ) < 0) \
678     { \
679         WARN(txt ": %s\n", snd_strerror(err)); \
680         retcode=e; \
681         goto errexit; \
682     } \
683 } while(0)
684
685     sw_params = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_sw_params_sizeof() );
686     snd_pcm_hw_params_malloc(&hw_params);
687     if (! hw_params)
688     {
689         retcode = MMSYSERR_NOMEM;
690         goto errexit;
691     }
692     snd_pcm_hw_params_any(pcm, hw_params);
693
694     access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
695     if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
696         WARN("mmap not available. switching to standard write.\n");
697         access = SND_PCM_ACCESS_RW_INTERLEAVED;
698         EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
699         wwo->write = snd_pcm_writei;
700     }
701     else
702         wwo->write = snd_pcm_mmap_writei;
703
704     if ((err = snd_pcm_hw_params_set_channels(pcm, hw_params, wwo->format.Format.nChannels)) < 0) {
705         WARN("unable to set required channels: %d\n", wwo->format.Format.nChannels);
706         EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwo->format.Format.nChannels ), WAVERR_BADFORMAT, "unable to set required channels" );
707     }
708
709     if ((wwo->format.Format.wFormatTag == WAVE_FORMAT_PCM) ||
710         ((wwo->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
711         IsEqualGUID(&wwo->format.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) {
712         format = (wwo->format.Format.wBitsPerSample == 8) ? SND_PCM_FORMAT_U8 :
713                  (wwo->format.Format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE :
714                  (wwo->format.Format.wBitsPerSample == 24) ? SND_PCM_FORMAT_S24_3LE :
715                  (wwo->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_S32_LE : -1;
716     } else if ((wwo->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
717         IsEqualGUID(&wwo->format.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)){
718         format = (wwo->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_FLOAT_LE : -1;
719     } else {
720         ERR("invalid format: %0x04x\n", wwo->format.Format.wFormatTag);
721         retcode = WAVERR_BADFORMAT;
722         goto errexit;
723     }
724
725     if ((err = snd_pcm_hw_params_set_format(pcm, hw_params, format)) < 0) {
726         WARN("unable to set required format: %s\n", snd_pcm_format_name(format));
727         EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), WAVERR_BADFORMAT, "unable to set required format" );
728     }
729
730     rate = wwo->format.Format.nSamplesPerSec;
731     dir=0;
732     err = snd_pcm_hw_params_set_rate_near(pcm, hw_params, &rate, &dir);
733     if (err < 0) {
734         WARN("Rate %d Hz not available for playback: %s\n", wwo->format.Format.nSamplesPerSec, snd_strerror(rate));
735         retcode = WAVERR_BADFORMAT;
736         goto errexit;
737     }
738     if (!ALSA_NearMatch(rate, wwo->format.Format.nSamplesPerSec)) {
739         WARN("Rate doesn't match (requested %d Hz, got %d Hz)\n", wwo->format.Format.nSamplesPerSec, rate);
740         retcode = WAVERR_BADFORMAT;
741         goto errexit;
742     }
743
744     TRACE("Got this format: %dx%dx%d %s\n",
745           wwo->format.Format.nSamplesPerSec,
746           wwo->format.Format.wBitsPerSample,
747           wwo->format.Format.nChannels,
748           ALSA_getFormat(wwo->format.Format.wFormatTag));
749
750     dir=0;
751     EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, &buffer_time, &dir), MMSYSERR_INVALPARAM, "unable to set buffer time");
752     dir=0;
753     EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm, hw_params, &period_time, &dir), MMSYSERR_INVALPARAM, "unable to set period time");
754
755     EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
756
757     err = snd_pcm_hw_params_get_period_size(hw_params, &period_size, &dir);
758     err = snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
759
760     snd_pcm_sw_params_current(pcm, sw_params);
761
762     EXIT_ON_ERROR( snd_pcm_sw_params_set_start_threshold(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set start threshold");
763     EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence size");
764     EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
765     EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
766     EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
767 #undef EXIT_ON_ERROR
768
769     snd_pcm_prepare(pcm);
770
771     if (TRACE_ON(wave))
772         ALSA_TraceParameters(hw_params, sw_params, FALSE);
773
774     /* now, we can save all required data for later use... */
775
776     wwo->dwBufferSize = snd_pcm_frames_to_bytes(pcm, buffer_size);
777     wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
778     wwo->dwPlayedTotal = wwo->dwWrittenTotal = 0;
779     wwo->dwPartialOffset = 0;
780
781     ALSA_InitRingMessage(&wwo->msgRing);
782
783     wwo->hStartUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
784     wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD_PTR)wDevID, 0, &(wwo->dwThreadID));
785     if (wwo->hThread)
786         SetThreadPriority(wwo->hThread, THREAD_PRIORITY_TIME_CRITICAL);
787     else
788     {
789         ERR("Thread creation for the wodPlayer failed!\n");
790         CloseHandle(wwo->hStartUpEvent);
791         retcode = MMSYSERR_NOMEM;
792         goto errexit;
793     }
794     WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
795     CloseHandle(wwo->hStartUpEvent);
796     wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
797
798     TRACE("handle=%p\n", pcm);
799     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
800           wwo->format.Format.wBitsPerSample, wwo->format.Format.nAvgBytesPerSec,
801           wwo->format.Format.nSamplesPerSec, wwo->format.Format.nChannels,
802           wwo->format.Format.nBlockAlign);
803
804     HeapFree( GetProcessHeap(), 0, sw_params );
805     wwo->pcm = pcm;
806     wwo->hctl = hctl;
807     if ( wwo->hw_params )
808         snd_pcm_hw_params_free(wwo->hw_params);
809     wwo->hw_params = hw_params;
810
811     return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
812
813 errexit:
814     if (pcm)
815         snd_pcm_close(pcm);
816
817     if (hctl)
818     {
819         snd_hctl_free(hctl);
820         snd_hctl_close(hctl);
821     }
822
823     if ( hw_params )
824         snd_pcm_hw_params_free(hw_params);
825
826     HeapFree( GetProcessHeap(), 0, sw_params );
827     if (wwo->msgRing.ring_buffer_size > 0)
828         ALSA_DestroyRingMessage(&wwo->msgRing);
829
830     return retcode;
831 }
832
833
834 /**************************************************************************
835  *                              wodClose                        [internal]
836  */
837 static DWORD wodClose(WORD wDevID)
838 {
839     DWORD               ret = MMSYSERR_NOERROR;
840     WINE_WAVEDEV*       wwo;
841
842     TRACE("(%u);\n", wDevID);
843
844     if (wDevID >= ALSA_WodNumDevs) {
845         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
846         return MMSYSERR_BADDEVICEID;
847     }
848
849     if (WOutDev[wDevID].pcm == NULL) {
850         WARN("Requested to close already closed device %d!\n", wDevID);
851         return MMSYSERR_BADDEVICEID;
852     }
853
854     wwo = &WOutDev[wDevID];
855     if (wwo->lpQueuePtr) {
856         WARN("buffers still playing !\n");
857         ret = WAVERR_STILLPLAYING;
858     } else {
859         if (wwo->hThread != INVALID_HANDLE_VALUE) {
860             ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_CLOSING, 0, TRUE);
861         }
862         ALSA_DestroyRingMessage(&wwo->msgRing);
863
864         if (wwo->hw_params)
865             snd_pcm_hw_params_free(wwo->hw_params);
866         wwo->hw_params = NULL;
867
868         if (wwo->pcm)
869             snd_pcm_close(wwo->pcm);
870         wwo->pcm = NULL;
871
872         if (wwo->hctl)
873         {
874             snd_hctl_free(wwo->hctl);
875             snd_hctl_close(wwo->hctl);
876         }
877         wwo->hctl = NULL;
878
879         ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
880     }
881
882     return ret;
883 }
884
885
886 /**************************************************************************
887  *                              wodWrite                        [internal]
888  *
889  */
890 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
891 {
892     TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
893
894     if (wDevID >= ALSA_WodNumDevs) {
895         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
896         return MMSYSERR_BADDEVICEID;
897     }
898
899     if (WOutDev[wDevID].pcm == NULL) {
900         WARN("Requested to write to closed device %d!\n", wDevID);
901         return MMSYSERR_BADDEVICEID;
902     }
903
904     if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
905         return WAVERR_UNPREPARED;
906
907     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
908         return WAVERR_STILLPLAYING;
909
910     lpWaveHdr->dwFlags &= ~WHDR_DONE;
911     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
912     lpWaveHdr->lpNext = 0;
913
914     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD_PTR)lpWaveHdr, FALSE);
915
916     return MMSYSERR_NOERROR;
917 }
918
919 /**************************************************************************
920  *                      wodPause                                [internal]
921  */
922 static DWORD wodPause(WORD wDevID)
923 {
924     TRACE("(%u);!\n", wDevID);
925
926     if (wDevID >= ALSA_WodNumDevs) {
927         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
928         return MMSYSERR_BADDEVICEID;
929     }
930
931     if (WOutDev[wDevID].pcm == NULL) {
932         WARN("Requested to pause closed device %d!\n", wDevID);
933         return MMSYSERR_BADDEVICEID;
934     }
935
936     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_PAUSING, 0, TRUE);
937
938     return MMSYSERR_NOERROR;
939 }
940
941 /**************************************************************************
942  *                      wodRestart                              [internal]
943  */
944 static DWORD wodRestart(WORD wDevID)
945 {
946     TRACE("(%u);\n", wDevID);
947
948     if (wDevID >= ALSA_WodNumDevs) {
949         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
950         return MMSYSERR_BADDEVICEID;
951     }
952
953     if (WOutDev[wDevID].pcm == NULL) {
954         WARN("Requested to restart closed device %d!\n", wDevID);
955         return MMSYSERR_BADDEVICEID;
956     }
957
958     if (WOutDev[wDevID].state == WINE_WS_PAUSED) {
959         ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESTARTING, 0, TRUE);
960     }
961
962     /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
963     /* FIXME: Myst crashes with this ... hmm -MM
964        return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
965     */
966
967     return MMSYSERR_NOERROR;
968 }
969
970 /**************************************************************************
971  *                      wodReset                                [internal]
972  */
973 static DWORD wodReset(WORD wDevID)
974 {
975     TRACE("(%u);\n", wDevID);
976
977     if (wDevID >= ALSA_WodNumDevs) {
978         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
979         return MMSYSERR_BADDEVICEID;
980     }
981
982     if (WOutDev[wDevID].pcm == NULL) {
983         WARN("Requested to reset closed device %d!\n", wDevID);
984         return MMSYSERR_BADDEVICEID;
985     }
986
987     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
988
989     return MMSYSERR_NOERROR;
990 }
991
992 /**************************************************************************
993  *                              wodGetPosition                  [internal]
994  */
995 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
996 {
997     WINE_WAVEDEV*       wwo;
998
999     TRACE("(%u, %p, %u);\n", wDevID, lpTime, uSize);
1000
1001     if (wDevID >= ALSA_WodNumDevs) {
1002         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
1003         return MMSYSERR_BADDEVICEID;
1004     }
1005
1006     if (WOutDev[wDevID].pcm == NULL) {
1007         WARN("Requested to get position of closed device %d!\n", wDevID);
1008         return MMSYSERR_BADDEVICEID;
1009     }
1010
1011     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1012
1013     wwo = &WOutDev[wDevID];
1014     return ALSA_bytes_to_mmtime(lpTime, wwo->dwPlayedTotal, &wwo->format);
1015 }
1016
1017 /**************************************************************************
1018  *                              wodBreakLoop                    [internal]
1019  */
1020 static DWORD wodBreakLoop(WORD wDevID)
1021 {
1022     TRACE("(%u);\n", wDevID);
1023
1024     if (wDevID >= ALSA_WodNumDevs) {
1025         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
1026         return MMSYSERR_BADDEVICEID;
1027     }
1028
1029     if (WOutDev[wDevID].pcm == NULL) {
1030         WARN("Requested to breakloop of closed device %d!\n", wDevID);
1031         return MMSYSERR_BADDEVICEID;
1032     }
1033
1034     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_BREAKLOOP, 0, TRUE);
1035     return MMSYSERR_NOERROR;
1036 }
1037
1038 /**************************************************************************
1039  *                              wodGetVolume                    [internal]
1040  */
1041 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1042 {
1043     WORD               wleft, wright;
1044     WINE_WAVEDEV*      wwo;
1045     int                min, max;
1046     int                left, right;
1047     DWORD              rc;
1048
1049     TRACE("(%u, %p);\n", wDevID, lpdwVol);
1050     if (wDevID >= ALSA_WodNumDevs) {
1051         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
1052         return MMSYSERR_BADDEVICEID;
1053     }
1054
1055     if (lpdwVol == NULL)
1056         return MMSYSERR_NOTENABLED;
1057
1058     wwo = &WOutDev[wDevID];
1059
1060     rc = ALSA_CheckSetVolume(wwo->hctl, &left, &right, &min, &max, NULL, NULL, NULL);
1061     if (rc == MMSYSERR_NOERROR)
1062     {
1063 #define VOLUME_ALSA_TO_WIN(x) (  ( (((x)-min) * 65535) + (max-min)/2 ) /(max-min))
1064         wleft = VOLUME_ALSA_TO_WIN(left);
1065         wright = VOLUME_ALSA_TO_WIN(right);
1066 #undef VOLUME_ALSA_TO_WIN
1067         TRACE("left=%d,right=%d,converted to windows left %d, right %d\n", left, right, wleft, wright);
1068         *lpdwVol = MAKELONG( wleft, wright );
1069     }
1070     else
1071         TRACE("CheckSetVolume failed; rc %d\n", rc);
1072
1073     return rc;
1074 }
1075
1076 /**************************************************************************
1077  *                              wodSetVolume                    [internal]
1078  */
1079 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1080 {
1081     WORD               wleft, wright;
1082     WINE_WAVEDEV*      wwo;
1083     int                min, max;
1084     int                left, right;
1085     DWORD              rc;
1086
1087     TRACE("(%u, %08X);\n", wDevID, dwParam);
1088     if (wDevID >= ALSA_WodNumDevs) {
1089         TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
1090         return MMSYSERR_BADDEVICEID;
1091     }
1092
1093     wwo = &WOutDev[wDevID];
1094
1095     rc = ALSA_CheckSetVolume(wwo->hctl, NULL, NULL, &min, &max, NULL, NULL, NULL);
1096     if (rc == MMSYSERR_NOERROR)
1097     {
1098         wleft  = LOWORD(dwParam);
1099         wright = HIWORD(dwParam);
1100 #define VOLUME_WIN_TO_ALSA(x) ( (  ( ((x) * (max-min)) + 32767) / 65535) + min )
1101         left = VOLUME_WIN_TO_ALSA(wleft);
1102         right = VOLUME_WIN_TO_ALSA(wright);
1103 #undef VOLUME_WIN_TO_ALSA
1104         rc = ALSA_CheckSetVolume(wwo->hctl, NULL, NULL, NULL, NULL, NULL, &left, &right);
1105         if (rc == MMSYSERR_NOERROR)
1106             TRACE("set volume:  wleft=%d, wright=%d, converted to alsa left %d, right %d\n", wleft, wright, left, right);
1107         else
1108             TRACE("SetVolume failed; rc %d\n", rc);
1109     }
1110
1111     return rc;
1112 }
1113
1114 /**************************************************************************
1115  *                              wodGetNumDevs                   [internal]
1116  */
1117 static  DWORD   wodGetNumDevs(void)
1118 {
1119     return ALSA_WodNumDevs;
1120 }
1121
1122 /**************************************************************************
1123  *                              wodDevInterfaceSize             [internal]
1124  */
1125 static DWORD wodDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
1126 {
1127     TRACE("(%u, %p)\n", wDevID, dwParam1);
1128
1129     *dwParam1 = MultiByteToWideChar(CP_UNIXCP, 0, WOutDev[wDevID].interface_name, -1,
1130                                     NULL, 0 ) * sizeof(WCHAR);
1131     return MMSYSERR_NOERROR;
1132 }
1133
1134 /**************************************************************************
1135  *                              wodDevInterface                 [internal]
1136  */
1137 static DWORD wodDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
1138 {
1139     if (dwParam2 >= MultiByteToWideChar(CP_UNIXCP, 0, WOutDev[wDevID].interface_name, -1,
1140                                         NULL, 0 ) * sizeof(WCHAR))
1141     {
1142         MultiByteToWideChar(CP_UNIXCP, 0, WOutDev[wDevID].interface_name, -1,
1143                             dwParam1, dwParam2 / sizeof(WCHAR));
1144         return MMSYSERR_NOERROR;
1145     }
1146     return MMSYSERR_INVALPARAM;
1147 }
1148
1149 /**************************************************************************
1150  *                              wodMessage (WINEALSA.@)
1151  */
1152 DWORD WINAPI ALSA_wodMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
1153                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1154 {
1155     TRACE("(%u, %s, %08lX, %08lX, %08lX);\n",
1156           wDevID, ALSA_getMessage(wMsg), dwUser, dwParam1, dwParam2);
1157
1158     switch (wMsg) {
1159     case DRVM_INIT:
1160         ALSA_WaveInit();
1161     case DRVM_EXIT:
1162     case DRVM_ENABLE:
1163     case DRVM_DISABLE:
1164         /* FIXME: Pretend this is supported */
1165         return 0;
1166     case WODM_OPEN:             return wodOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,      dwParam2);
1167     case WODM_CLOSE:            return wodClose         (wDevID);
1168     case WODM_GETDEVCAPS:       return wodGetDevCaps    (wDevID, (LPWAVEOUTCAPSW)dwParam1,      dwParam2);
1169     case WODM_GETNUMDEVS:       return wodGetNumDevs    ();
1170     case WODM_GETPITCH:         return MMSYSERR_NOTSUPPORTED;
1171     case WODM_SETPITCH:         return MMSYSERR_NOTSUPPORTED;
1172     case WODM_GETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1173     case WODM_SETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1174     case WODM_WRITE:            return wodWrite         (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1175     case WODM_PAUSE:            return wodPause         (wDevID);
1176     case WODM_GETPOS:           return wodGetPosition   (wDevID, (LPMMTIME)dwParam1,            dwParam2);
1177     case WODM_BREAKLOOP:        return wodBreakLoop     (wDevID);
1178     case WODM_PREPARE:          return MMSYSERR_NOTSUPPORTED;
1179     case WODM_UNPREPARE:        return MMSYSERR_NOTSUPPORTED;
1180     case WODM_GETVOLUME:        return wodGetVolume     (wDevID, (LPDWORD)dwParam1);
1181     case WODM_SETVOLUME:        return wodSetVolume     (wDevID, dwParam1);
1182     case WODM_RESTART:          return wodRestart       (wDevID);
1183     case WODM_RESET:            return wodReset         (wDevID);
1184     case DRV_QUERYDEVICEINTERFACESIZE: return wodDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
1185     case DRV_QUERYDEVICEINTERFACE:     return wodDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
1186     case DRV_QUERYDSOUNDIFACE:  return wodDsCreate      (wDevID, (PIDSDRIVER*)dwParam1);
1187     case DRV_QUERYDSOUNDDESC:   return wodDsDesc        (wDevID, (PDSDRIVERDESC)dwParam1);
1188
1189     default:
1190         FIXME("unknown message %d!\n", wMsg);
1191     }
1192     return MMSYSERR_NOTSUPPORTED;
1193 }
1194
1195 #else /* HAVE_ALSA */
1196
1197 /**************************************************************************
1198  *                              wodMessage (WINEALSA.@)
1199  */
1200 DWORD WINAPI ALSA_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1201                              DWORD dwParam1, DWORD dwParam2)
1202 {
1203     FIXME("(%u, %04X, %08X, %08X, %08X):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
1204     return MMSYSERR_NOTENABLED;
1205 }
1206
1207 #endif /* HAVE_ALSA */