ALSA driver

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



this patch is the first attempt at providing an ALSA driver to Wine
it includes:
- an quick audio implementation for ALSA 0.5 interface
- a more complete audio implementation for ALSA 0.9 (buffered and
mmap:ed for DSound), eventhough still lots of stuff needs to be
implemented

on the todo list, there's:
- implementation of the remaining of the driver (mainly for the
0.9/final interface for midi, mixer...)
- enhance configuration bits. as of today, we cannot build a DLL which
will be compatible, based on what's available on the machine on the 0.5
or final interface

to enable it, change your ~/.wine/config file, in the WinMM section to
have:
Drivers=winealsa.drv
(and be sure you have alsa installed ;-)

A+
Name:          alsa
ChangeLog:     created an ALSA driver
License:       X11
GenDate:       2002/06/25 19:12:44 UTC
ModifiedFiles: configure.ac dlls/Makefile.in
AddedFiles:    dlls/winmm/winealsa/Makefile.in dlls/winmm/winealsa/alsa.h dlls/winmm/winealsa/alsa.c dlls/winmm/winealsa/audio.c dlls/winmm/winealsa/audio_05.c dlls/winmm/winealsa/winealsa.drv.spec dlls/winmm/winealsa/.cvsignore
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/configure.ac,v
retrieving revision 1.52
diff -u -u -r1.52 configure.ac
--- configure.ac	24 Jun 2002 23:00:26 -0000	1.52
+++ configure.ac	25 Jun 2002 05:13:13 -0000
@@ -1320,7 +1321,8 @@
 dlls/winmm/mciseq/Makefile
 dlls/winmm/mciwave/Makefile
 dlls/winmm/midimap/Makefile
 dlls/winmm/wavemap/Makefile
+dlls/winmm/winealsa/Makefile
 dlls/winmm/winearts/Makefile
 dlls/winmm/wineoss/Makefile
 dlls/winnls/Makefile
Index: dlls/Makefile.in
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/Makefile.in,v
retrieving revision 1.139
diff -u -u -r1.139 Makefile.in
--- dlls/Makefile.in	14 Jun 2002 23:48:27 -0000	1.139
+++ dlls/Makefile.in	22 Jun 2002 16:15:24 -0000
@@ -94,7 +95,8 @@
 	winmm/mciseq \
 	winmm/mciwave \
 	winmm/midimap \
 	winmm/wavemap \
+	winmm/winealsa \
 	winmm/winearts \
 	winmm/wineoss \
 	winnls \
@@ -235,6 +240,7 @@
 	win87em.dll$(DLLEXT) \
 	winaspi.dll$(DLLEXT) \
 	windebug.dll$(DLLEXT) \
+	winealsa.drv$(DLLEXT) \
 	winearts.drv$(DLLEXT) \
 	winedos.dll$(DLLEXT) \
 	winemp3.acm$(DLLEXT) \
@@ -494,6 +506,9 @@
 w32skrnl.dll$(DLLEXT) w32sys.dll$(DLLEXT) win32s16.dll$(DLLEXT): win32s/w32skrnl.dll$(DLLEXT)
 	$(RM) $@ && $(LN_S) win32s/w32skrnl.dll$(DLLEXT) $@
 
+winealsa.drv$(DLLEXT): winmm/winealsa/winealsa.drv$(DLLEXT)
+	$(RM) $@ && $(LN_S) winmm/winealsa/winealsa.drv$(DLLEXT) $@
+
 winearts.drv$(DLLEXT): winmm/winearts/winearts.drv$(DLLEXT)
 	$(RM) $@ && $(LN_S) winmm/winearts/winearts.drv$(DLLEXT) $@
 
@@ -618,6 +635,7 @@
 user/user32.dll$(DLLEXT): user
 version/version.dll$(DLLEXT): version
 win32s/w32skrnl.dll$(DLLEXT): win32s
+winmm/winealsa/winealsa.drv$(DLLEXT): winmm/winealsa
 winmm/winearts/winearts.drv$(DLLEXT): winmm/winearts
 winedos/winedos.dll$(DLLEXT): winedos
 msacm/winemp3/winemp3.acm$(DLLEXT): msacm/winemp3
@@ -823,7 +842,8 @@
 winmm/mciseq: winmm.dll$(DLLEXT) user32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
 winmm/mciwave: winmm.dll$(DLLEXT) user32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
 winmm/midimap: winmm.dll$(DLLEXT) user32.dll$(DLLEXT) advapi32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
 winmm/wavemap: msacm32.dll$(DLLEXT) winmm.dll$(DLLEXT) user32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
+winmm/winealsa: winmm.dll$(DLLEXT) user32.dll$(DLLEXT) kernel32.dll$(DLLEXT) ntdll.dll$(DLLEXT)
 winmm/winearts: winmm.dll$(DLLEXT) user32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
 winmm/wineoss: winmm.dll$(DLLEXT) user32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
 winmm:    user32.dll$(DLLEXT) advapi32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/winmm/winealsa/Makefile.in	Tue Jun  4 22:23:39 2002
@@ -0,0 +1,20 @@
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../../..
+SRCDIR    = @srcdir@
+VPATH     = @srcdir@
+MODULE    = winealsa.drv
+IMPORTS   = winmm user32 kernel32 ntdll
+
+LDDLLFLAGS = @LDDLLFLAGS@
+SYMBOLFILE = $(MODULE).tmp.o
+
+EXTRALIBS  = -lasound
+
+C_SRCS = \
+	audio.c \
+	audio_05.c \
+	alsa.c
+
+@MAKE_DLL_RULES@
+
+### Dependencies:
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/winmm/winealsa/alsa.h	Mon Jan 14 21:16:44 2002
@@ -0,0 +1,13 @@
+/* Definition for ALSA drivers : wine multimedia system */
+
+#ifndef __WINE_CONFIG_H 
+# error You must include config.h to use this header 
+#endif 
+
+#include <sys/asoundlib.h>
+#ifdef HAVE_SYS_ERRNO_H
+#include <sys/errno.h>
+#endif
+
+extern LONG ALSA_WaveInit(void);
+
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/winmm/winealsa/alsa.c	Tue Jun  4 22:53:56 2002
@@ -0,0 +1,77 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+/*				   
+ * Wine Driver for ALSA
+ *
+ * Copyright 	2002 Eric Pouech
+ */
+
+#include "config.h"
+
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "mmddk.h"
+#include "alsa.h"
+
+#ifdef HAVE_ALSA
+
+static	struct WINE_ALSA* alsa = NULL;
+
+/**************************************************************************
+ * 				ALSA_drvOpen			[internal]	
+ */
+static	DWORD	ALSA_drvOpen(LPSTR str)
+{
+    if (alsa)
+	return 0;
+    
+    /* I know, this is ugly, but who cares... */
+    alsa = (struct WINE_ALSA*)1;
+    return 1;
+}
+
+/**************************************************************************
+ * 				ALSA_drvClose			[internal]	
+ */
+static	DWORD	ALSA_drvClose(DWORD dwDevID)
+{
+    if (alsa) {
+	alsa = NULL;
+	return 1;
+    }
+    return 0;
+}
+
+#endif
+
+
+/**************************************************************************
+ * 				DriverProc (WINEALSA.1)
+ */
+LONG CALLBACK	ALSA_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg, 
+			       DWORD dwParam1, DWORD dwParam2)
+{
+/* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
+/* EPP 	  dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
+    
+    switch(wMsg) {
+#ifdef HAVE_ALSA
+    case DRV_LOAD:		ALSA_WaveInit(); 
+				return 1;
+    case DRV_FREE:		return 1;
+    case DRV_OPEN:		return ALSA_drvOpen((LPSTR)dwParam1);
+    case DRV_CLOSE:		return ALSA_drvClose(dwDevID);
+    case DRV_ENABLE:		return 1;
+    case DRV_DISABLE:		return 1;
+    case DRV_QUERYCONFIGURE:	return 1;
+    case DRV_CONFIGURE:		MessageBoxA(0, "ALSA MultiMedia Driver !", "ALSA Driver", MB_OK);	return 1;
+    case DRV_INSTALL:		return DRVCNF_RESTART;
+    case DRV_REMOVE:		return DRVCNF_RESTART;
+#endif
+    default:
+	return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
+    }
+}
+
+
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/winmm/winealsa/audio.c	Tue Jun  4 22:33:37 2002
@@ -0,0 +1,2089 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+/*				   
+ * Sample Wine Driver for Advanced Linux Sound System (ALSA)
+ *      Based on version <final> of the ALSA API
+ *
+ * Copyright    2002 Eric Pouech
+ *              2002 Marco Pietrobono
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <values.h>
+#ifdef HAVE_SYS_MMAN_H
+# include <sys/mman.h>
+#endif
+#include "winbase.h"
+#include "windef.h"
+#include "wingdi.h"
+#include "winerror.h"
+#include "winuser.h"
+#include "mmddk.h"
+#include "dsound.h"
+#include "dsdriver.h"
+#include "alsa.h"
+#include "wine/debug.h"
+#include "wine/port.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wave);
+
+
+#if defined(HAVE_ALSA) && ((SND_LIB_MAJOR == 0 && SND_LIB_MINOR >= 9) || SND_LIB_MAJOR >= 1)
+
+/* internal ALSALIB functions */
+snd_pcm_uframes_t _snd_pcm_mmap_hw_ptr(snd_pcm_t *pcm);
+
+
+#define MAX_WAVEOUTDRV 	(1)
+#define MAX_WAVEINDRV 	(1)
+
+/* state diagram for waveOut writing:
+ *
+ * +---------+-------------+---------------+---------------------------------+
+ * |  state  |  function   |     event     |            new state	     |
+ * +---------+-------------+---------------+---------------------------------+
+ * |	     | open()	   |		   | STOPPED		       	     |
+ * | PAUSED  | write()	   | 		   | PAUSED		       	     |
+ * | STOPPED | write()	   | <thrd create> | PLAYING		  	     |
+ * | PLAYING | write()	   | HEADER        | PLAYING		  	     |
+ * | (other) | write()	   | <error>       |		       		     |
+ * | (any)   | pause()	   | PAUSING	   | PAUSED		       	     |
+ * | PAUSED  | restart()   | RESTARTING    | PLAYING (if no thrd => STOPPED) |
+ * | (any)   | reset()	   | RESETTING     | STOPPED		      	     |
+ * | (any)   | close()	   | CLOSING	   | CLOSED		      	     |
+ * +---------+-------------+---------------+---------------------------------+
+ */
+
+/* states of the playing device */
+#define	WINE_WS_PLAYING		0
+#define	WINE_WS_PAUSED		1
+#define	WINE_WS_STOPPED		2
+#define WINE_WS_CLOSED		3
+
+/* events to be send to device */
+enum win_wm_message {
+    WINE_WM_PAUSING = WM_USER + 1, WINE_WM_RESTARTING, WINE_WM_RESETTING, WINE_WM_HEADER,
+    WINE_WM_UPDATE, WINE_WM_BREAKLOOP, WINE_WM_CLOSING
+};
+
+typedef struct {
+    enum win_wm_message 	msg;	/* message identifier */
+    DWORD	                param;  /* parameter for this message */
+    HANDLE	                hEvent;	/* if message is synchronous, handle of event for synchro */
+} ALSA_MSG;
+
+/* implement an in-process message ring for better performance 
+ * (compared to passing thru the server)
+ * this ring will be used by the input (resp output) record (resp playback) routine
+ */
+typedef struct {
+    /* FIXME: this could be made a dynamically growing array (if needed) */
+#define ALSA_RING_BUFFER_SIZE	30
+    ALSA_MSG			messages[ALSA_RING_BUFFER_SIZE];
+    int				msg_tosave;
+    int				msg_toget;
+    HANDLE			msg_event;
+    CRITICAL_SECTION		msg_crst;
+} ALSA_MSG_RING;
+
+typedef struct {
+    /* Windows information */
+    volatile int		state;			/* one of the WINE_WS_ manifest constants */
+    WAVEOPENDESC		waveDesc;
+    WORD			wFlags;
+    PCMWAVEFORMAT		format;
+    WAVEOUTCAPSA		caps;
+
+    /* ALSA information (ALSA 0.9/1.x uses two different devices for playback/capture) */
+    char *			device;
+    snd_pcm_t*                  p_handle;                 /* handle to ALSA playback device */
+    snd_pcm_t*                  c_handle;                 /* handle to ALSA capture device */
+    snd_pcm_hw_params_t *	hw_params;		/* ALSA Hw params */
+
+    snd_ctl_t *                 ctl;                    /* control handle for the playback volume */
+    snd_ctl_elem_id_t *         playback_eid;		/* element id of the playback volume control */
+    snd_ctl_elem_value_t *      playback_evalue;	/* element value of the playback volume control */
+    snd_ctl_elem_info_t *       playback_einfo;         /* element info of the playback volume control */
+
+    snd_pcm_sframes_t           (*write)(snd_pcm_t *, const void *, snd_pcm_uframes_t );
+
+    DWORD                       dwBufferSize;           /* size of whole ALSA buffer in bytes */
+    LPWAVEHDR			lpQueuePtr;		/* start of queued WAVEHDRs (waiting to be notified) */
+    LPWAVEHDR			lpPlayPtr;		/* start of not yet fully played buffers */
+
+    LPWAVEHDR			lpLoopPtr;              /* pointer of first buffer in loop, if any */
+    DWORD			dwLoops;		/* private copy of loop counter */
+
+    DWORD			dwPlayedTotal;
+
+    /* synchronization stuff */
+    HANDLE			hStartUpEvent;
+    HANDLE			hThread;
+    DWORD			dwThreadID;
+    ALSA_MSG_RING		msgRing;
+
+    /* DirectSound stuff */
+
+} WINE_WAVEOUT;
+
+static WINE_WAVEOUT	WOutDev   [MAX_WAVEOUTDRV];
+static DWORD            ALSA_WodNumDevs;
+
+static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv);
+ 
+/* These strings used only for tracing */
+static const char *wodPlayerCmdString[] = {
+    "WINE_WM_PAUSING",
+    "WINE_WM_RESTARTING",
+    "WINE_WM_RESETTING",
+    "WINE_WM_HEADER",
+    "WINE_WM_UPDATE",
+    "WINE_WM_BREAKLOOP",
+    "WINE_WM_CLOSING",
+};
+
+/*======================================================================*
+ *                  Low level WAVE implementation			*
+ *======================================================================*/
+
+/**************************************************************************
+ * 			ALSA_InitializeVolumeCtl		[internal]
+ *
+ * used to initialize the PCM Volume Control
+ */
+static int ALSA_InitializeVolumeCtl(WINE_WAVEOUT * wwo)
+{
+    snd_ctl_t *                 ctl = NULL;
+    snd_ctl_card_info_t *	cardinfo;
+    snd_ctl_elem_list_t *       elemlist;
+    snd_ctl_elem_id_t *         e_id;
+    snd_ctl_elem_info_t *       einfo;
+    snd_hctl_t *                hctl = NULL;
+    snd_hctl_elem_t *           elem;
+    int                         nCtrls;
+    int                         i;
+
+    snd_ctl_card_info_alloca(&cardinfo);
+    memset(cardinfo,0,snd_ctl_card_info_sizeof());
+
+    snd_ctl_elem_list_alloca(&elemlist);
+    memset(elemlist,0,snd_ctl_elem_list_sizeof());
+
+    snd_ctl_elem_id_alloca(&e_id);
+    memset(e_id,0,snd_ctl_elem_id_sizeof());
+
+    snd_ctl_elem_info_alloca(&einfo);
+    memset(einfo,0,snd_ctl_elem_info_sizeof());
+
+#define EXIT_ON_ERROR(f,txt) do \
+{ \
+    int err; \
+    if ( (err = (f) ) < 0) \
+    { \
+	ERR(txt ": %s\n", snd_strerror(err)); \
+	if (hctl) \
+	    snd_hctl_close(hctl); \
+	if (ctl) \
+	    snd_ctl_close(ctl); \
+	return -1; \
+    } \
+} while(0)
+
+    EXIT_ON_ERROR( snd_ctl_open(&ctl,"hw:0",0) , "ctl open failed" );
+    EXIT_ON_ERROR( snd_ctl_card_info(ctl, cardinfo), "card info failed");
+    EXIT_ON_ERROR( snd_ctl_elem_list(ctl, elemlist), "elem list failed");
+
+    nCtrls = snd_ctl_elem_list_get_count(elemlist);
+
+    EXIT_ON_ERROR( snd_hctl_open(&hctl,"hw:0",0), "hctl open failed");
+    EXIT_ON_ERROR( snd_hctl_load(hctl), "hctl load failed" );
+
+    elem=snd_hctl_first_elem(hctl);
+    for ( i= 0; i<nCtrls; i++) {
+
+	memset(e_id,0,snd_ctl_elem_id_sizeof());
+
+	snd_hctl_elem_get_id(elem,e_id);
+/*
+	TRACE("ctl: #%d '%s'%d\n",
+				   snd_ctl_elem_id_get_numid(e_id),
+				   snd_ctl_elem_id_get_name(e_id),
+				   snd_ctl_elem_id_get_index(e_id));
+*/
+	if ( !strcmp("PCM Playback Volume", snd_ctl_elem_id_get_name(e_id)) )
+	{
+	    EXIT_ON_ERROR( snd_hctl_elem_info(elem,einfo), "hctl elem info failed" );
+
+	    /* few sanity checks... you'll never know... */
+	    if ( snd_ctl_elem_info_get_type(einfo) != SND_CTL_ELEM_TYPE_INTEGER )
+	    	WARN("playback volume control is not an integer\n");
+	    if ( !snd_ctl_elem_info_is_readable(einfo) )
+	    	WARN("playback volume control is readable\n");
+	    if ( !snd_ctl_elem_info_is_writable(einfo) )
+	    	WARN("playback volume control is readable\n");
+
+	    TRACE("   ctrl range: min=%ld  max=%ld  step=%ld\n",
+	         snd_ctl_elem_info_get_min(einfo),
+	         snd_ctl_elem_info_get_max(einfo),
+	         snd_ctl_elem_info_get_step(einfo));
+
+	    EXIT_ON_ERROR( snd_ctl_elem_id_malloc(&wwo->playback_eid), "elem id malloc failed" );
+	    EXIT_ON_ERROR( snd_ctl_elem_info_malloc(&wwo->playback_einfo), "elem info malloc failed" );
+	    EXIT_ON_ERROR( snd_ctl_elem_value_malloc(&wwo->playback_evalue), "elem value malloc failed" );
+
+	    /* ok, now we can safely save these objects for later */
+	    snd_ctl_elem_id_copy(wwo->playback_eid, e_id);
+	    snd_ctl_elem_info_copy(wwo->playback_einfo, einfo);
+	    snd_ctl_elem_value_set_id(wwo->playback_evalue, wwo->playback_eid);
+	    wwo->ctl = ctl;
+	}
+
+	elem=snd_hctl_elem_next(elem);
+    }
+    snd_hctl_close(hctl);
+#undef EXIT_ON_ERROR
+    return 0;
+}
+
+/**************************************************************************
+ * 			ALSA_XRUNRecovery		[internal]
+ *
+ * used to recovery from XRUN errors (buffer underflow/overflow)
+ */
+static int ALSA_XRUNRecovery(WINE_WAVEOUT * wwo, int err)
+{
+    if (err == -EPIPE) {    /* under-run */
+        err = snd_pcm_prepare(wwo->p_handle);
+        if (err < 0)
+             ERR( "underrun recovery failed. prepare failed: %s\n", snd_strerror(err));
+        return 0;
+    } else if (err == -ESTRPIPE) {
+        while ((err = snd_pcm_resume(wwo->p_handle)) == -EAGAIN)
+            sleep(1);       /* wait until the suspend flag is released */
+            if (err < 0) {
+                err = snd_pcm_prepare(wwo->p_handle);
+                if (err < 0)
+                    ERR("recovery from suspend failed, prepare failed: %s\n", snd_strerror(err));
+            }
+            return 0;
+    }
+    return err;
+}
+
+/**************************************************************************
+ * 			ALSA_TraceParameters		[internal]
+ *
+ * used to trace format changes, hw and sw parameters
+ */
+static void ALSA_TraceParameters(snd_pcm_hw_params_t * hw_params, snd_pcm_sw_params_t * sw, int full)
+{
+    snd_pcm_format_t   format = snd_pcm_hw_params_get_format(hw_params);
+    snd_pcm_access_t   access = snd_pcm_hw_params_get_access(hw_params);
+
+#define X(x) ((x)? "true" : "false")
+    if (full)
+	TRACE("FLAGS: sampleres=%s overrng=%s pause=%s resume=%s syncstart=%s batch=%s block=%s double=%s "
+    	      "halfd=%s joint=%s \n", 
+	      X(snd_pcm_hw_params_can_mmap_sample_resolution(hw_params)),
+	      X(snd_pcm_hw_params_can_overrange(hw_params)),
+	      X(snd_pcm_hw_params_can_pause(hw_params)),
+	      X(snd_pcm_hw_params_can_resume(hw_params)),
+	      X(snd_pcm_hw_params_can_sync_start(hw_params)),
+	      X(snd_pcm_hw_params_is_batch(hw_params)),
+	      X(snd_pcm_hw_params_is_block_transfer(hw_params)),
+	      X(snd_pcm_hw_params_is_double(hw_params)),
+	      X(snd_pcm_hw_params_is_half_duplex(hw_params)),
+	      X(snd_pcm_hw_params_is_joint_duplex(hw_params)));
+#undef X
+
+    if (access >= 0)
+	TRACE("access=%s\n", snd_pcm_access_name(access));
+    else
+    {
+	snd_pcm_access_mask_t * acmask;
+	snd_pcm_access_mask_alloca(&acmask);
+	snd_pcm_hw_params_get_access_mask(hw_params, acmask);
+	for ( access = SND_PCM_ACCESS_MMAP_INTERLEAVED; access <= SND_PCM_ACCESS_LAST; access++)
+	    if (snd_pcm_access_mask_test(acmask, access))
+		TRACE("access=%s\n", snd_pcm_access_name(access));
+    }
+
+    if (format >= 0)
+    {
+	TRACE("format=%s\n", snd_pcm_format_name(format));
+	
+    }
+    else
+    {
+	snd_pcm_format_mask_t *     fmask;
+
+	snd_pcm_format_mask_alloca(&fmask);
+	snd_pcm_hw_params_get_format_mask(hw_params, fmask);
+	for ( format = SND_PCM_FORMAT_S8; format <= SND_PCM_FORMAT_LAST ; format++)
+	    if ( snd_pcm_format_mask_test(fmask, format) )
+		TRACE("format=%s\n", snd_pcm_format_name(format));
+    }
+
+#define X(x) do { \
+int n = snd_pcm_hw_params_get_##x(hw_params); \
+if (n<0) \
+    TRACE(#x "_min=%ld " #x "_max=%ld\n", \
+        (long int)snd_pcm_hw_params_get_##x##_min(hw_params), \
+	(long int)snd_pcm_hw_params_get_##x##_max(hw_params)); \
+else \
+    TRACE(#x "=%d\n", n); \
+} while(0)
+    X(channels);
+    X(buffer_size);
+#undef X
+
+#define X(x) do { \
+int n = snd_pcm_hw_params_get_##x(hw_params,0); \
+if (n<0) \
+    TRACE(#x "_min=%ld " #x "_max=%ld\n", \
+        (long int)snd_pcm_hw_params_get_##x##_min(hw_params,0), \
+	(long int)snd_pcm_hw_params_get_##x##_max(hw_params,0)); \
+else \
+    TRACE(#x "=%d\n", n); \
+} while(0)
+    X(rate);
+    X(buffer_time);
+    X(periods);
+    X(period_size);
+    X(period_time);
+    X(tick_time);
+#undef X
+
+    if (!sw)
+	return;
+
+
+}
+
+
+
+/******************************************************************
+ *		ALSA_WaveInit
+ *
+ * Initialize internal structures from ALSA information
+ */
+LONG ALSA_WaveInit(void)
+{
+    snd_pcm_t*                  h;
+    snd_pcm_info_t *            info;
+    snd_pcm_hw_params_t *       hw_params;
+    WINE_WAVEOUT*	        wwo;
+
+    wwo = &WOutDev[0];
+
+    /* FIXME: use better values */
+    wwo->device = "hw:0,0";
+    wwo->caps.wMid = 0x0002;
+    wwo->caps.wPid = 0x0104;
+    strcpy(wwo->caps.szPname, "SB16 Wave Out");
+    wwo->caps.vDriverVersion = 0x0100;
+    wwo->caps.dwFormats = 0x00000000;
+    wwo->caps.dwSupport = WAVECAPS_VOLUME;
+
+    if (!wine_dlopen("libasound.so.2", RTLD_LAZY|RTLD_GLOBAL, NULL, 0))
+    {
+        ERR("Error: ALSA lib needs to be loaded with flags RTLD_LAZY and RTLD_GLOBAL.\n");
+        return -1;
+    }
+
+    snd_pcm_info_alloca(&info);
+    snd_pcm_hw_params_alloca(&hw_params);
+
+#define EXIT_ON_ERROR(f,txt) do { int err; if ( (err = (f) ) < 0) { ERR(txt ": %s\n", snd_strerror(err)); if (h) snd_pcm_close(h); return -1; } } while(0)
+
+    ALSA_WodNumDevs = 0; 
+    EXIT_ON_ERROR( snd_pcm_open(&h, wwo->device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) , "open pcm" );
+    ALSA_WodNumDevs++; 
+
+    EXIT_ON_ERROR( snd_pcm_info(h, info) , "pcm info" );
+
+    TRACE("dev=%d id=%s name=%s subdev=%d subdev_name=%s subdev_avail=%d subdev_num=%d stream=%s subclass=%s \n", 
+       snd_pcm_info_get_device(info),
+       snd_pcm_info_get_id(info),
+       snd_pcm_info_get_name(info),
+       snd_pcm_info_get_subdevice(info),
+       snd_pcm_info_get_subdevice_name(info),
+       snd_pcm_info_get_subdevices_avail(info),
+       snd_pcm_info_get_subdevices_count(info),
+       snd_pcm_stream_name(snd_pcm_info_get_stream(info)),
+       (snd_pcm_info_get_subclass(info) == SND_PCM_SUBCLASS_GENERIC_MIX ? "GENERIC MIX": "MULTI MIX"));
+
+    EXIT_ON_ERROR( snd_pcm_hw_params_any(h, hw_params) , "pcm hw params" );
+#undef EXIT_ON_ERROR
+
+    if (TRACE_ON(wave))
+	ALSA_TraceParameters(hw_params, NULL, TRUE);
+
+    {
+	snd_pcm_format_mask_t *     fmask;
+	int ratemin = snd_pcm_hw_params_get_rate_min(hw_params, 0);
+	int ratemax = snd_pcm_hw_params_get_rate_max(hw_params, 0);
+	int chmin = snd_pcm_hw_params_get_channels_min(hw_params); \
+	int chmax = snd_pcm_hw_params_get_channels_max(hw_params); \
+
+	snd_pcm_format_mask_alloca(&fmask);
+	snd_pcm_hw_params_get_format_mask(hw_params, fmask);
+       
+#define X(r,v) \
+       if ( (r) >= ratemin && ( (r) <= ratemax || ratemax == -1) ) \
+       { \
+          if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_U8)) \
+          { \
+              if (chmin <= 1 && 1 <= chmax) \
+                  wwo->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
+              if (chmin <= 2 && 2 <= chmax) \
+                  wwo->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
+          } \
+          if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_S16_LE)) \
+          { \
+              if (chmin <= 1 && 1 <= chmax) \
+                  wwo->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
+              if (chmin <= 2 && 2 <= chmax) \
+                  wwo->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
+          } \
+       }
+       X(11025,1);
+       X(22050,2);
+       X(44100,4);
+#undef X
+    }
+
+    if ( snd_pcm_hw_params_get_channels_min(hw_params) > 1) FIXME("-");
+    wwo->caps.wChannels = (snd_pcm_hw_params_get_channels_max(hw_params) >= 2) ? 2 : 1;
+    if (snd_pcm_hw_params_get_channels_min(hw_params) <= 2 && 2 <= snd_pcm_hw_params_get_channels_max(hw_params)) 
+        wwo->caps.dwSupport |= WAVECAPS_LRVOLUME;
+
+    /* FIXME: always true ? */
+    wwo->caps.dwSupport |= WAVECAPS_SAMPLEACCURATE;
+
+    {
+	snd_pcm_access_mask_t *     acmask;
+	snd_pcm_access_mask_alloca(&acmask);
+	snd_pcm_hw_params_get_access_mask(hw_params, acmask);
+
+	/* FIXME: NONITERLEAVED and COMPLEX are not supported right now */
+	if ( snd_pcm_access_mask_test( acmask, SND_PCM_ACCESS_MMAP_INTERLEAVED ) )
+            wwo->caps.dwSupport |= WAVECAPS_DIRECTSOUND;
+    }
+
+    TRACE("Configured with dwFmts=%08lx dwSupport=%08lx\n", 
+          wwo->caps.dwFormats, wwo->caps.dwSupport);
+    
+    snd_pcm_close(h);
+
+    ALSA_InitializeVolumeCtl(wwo);
+
+    return 0;
+}
+
+/******************************************************************
+ *		ALSA_InitRingMessage
+ *
+ * Initialize the ring of messages for passing between driver's caller and playback/record
+ * thread
+ */
+static int ALSA_InitRingMessage(ALSA_MSG_RING* omr)
+{
+    omr->msg_toget = 0;
+    omr->msg_tosave = 0;
+    omr->msg_event = CreateEventA(NULL, FALSE, FALSE, NULL);
+    memset(omr->messages, 0, sizeof(ALSA_MSG) * ALSA_RING_BUFFER_SIZE);
+    InitializeCriticalSection(&omr->msg_crst);
+    return 0;
+}
+
+/******************************************************************
+ *		ALSA_DestroyRingMessage
+ *
+ */
+static int ALSA_DestroyRingMessage(ALSA_MSG_RING* omr)
+{
+    CloseHandle(omr->msg_event);
+    DeleteCriticalSection(&omr->msg_crst);
+    return 0;
+}
+
+/******************************************************************
+ *		ALSA_AddRingMessage
+ *
+ * Inserts a new message into the ring (should be called from DriverProc derivated routines)
+ */
+static int ALSA_AddRingMessage(ALSA_MSG_RING* omr, enum win_wm_message msg, DWORD param, BOOL wait)
+{
+    HANDLE	hEvent = INVALID_HANDLE_VALUE;
+
+    EnterCriticalSection(&omr->msg_crst);
+    if ((omr->msg_toget == ((omr->msg_tosave + 1) % ALSA_RING_BUFFER_SIZE))) /* buffer overflow ? */
+    {
+	ERR("buffer overflow !?\n");
+        LeaveCriticalSection(&omr->msg_crst);
+	return 0;
+    }
+    if (wait)
+    {
+        hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+        if (hEvent == INVALID_HANDLE_VALUE)
+        {
+            ERR("can't create event !?\n");
+            LeaveCriticalSection(&omr->msg_crst);
+            return 0;
+        }
+        if (omr->msg_toget != omr->msg_tosave && omr->messages[omr->msg_toget].msg != WINE_WM_HEADER)
+            FIXME("two fast messages in the queue!!!!\n");
+
+        /* fast messages have to be added at the start of the queue */
+        omr->msg_toget = (omr->msg_toget + ALSA_RING_BUFFER_SIZE - 1) % ALSA_RING_BUFFER_SIZE;
+
+        omr->messages[omr->msg_toget].msg = msg;
+        omr->messages[omr->msg_toget].param = param;
+        omr->messages[omr->msg_toget].hEvent = hEvent;
+    }
+    else
+    { 
+        omr->messages[omr->msg_tosave].msg = msg;
+        omr->messages[omr->msg_tosave].param = param;
+        omr->messages[omr->msg_tosave].hEvent = INVALID_HANDLE_VALUE;
+        omr->msg_tosave = (omr->msg_tosave + 1) % ALSA_RING_BUFFER_SIZE;
+    }
+    LeaveCriticalSection(&omr->msg_crst);
+    /* signal a new message */
+    SetEvent(omr->msg_event);
+    if (wait)
+    {
+        /* wait for playback/record thread to have processed the message */
+        WaitForSingleObject(hEvent, INFINITE);
+        CloseHandle(hEvent);
+    }
+    return 1;
+}
+
+/******************************************************************
+ *		ALSA_RetrieveRingMessage
+ *
+ * Get a message from the ring. Should be called by the playback/record thread.
+ */
+static int ALSA_RetrieveRingMessage(ALSA_MSG_RING* omr, 
+                                   enum win_wm_message *msg, DWORD *param, HANDLE *hEvent)
+{
+    EnterCriticalSection(&omr->msg_crst);
+
+    if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
+    {
+        LeaveCriticalSection(&omr->msg_crst);
+	return 0;
+    }
+	
+    *msg = omr->messages[omr->msg_toget].msg;
+    omr->messages[omr->msg_toget].msg = 0;
+    *param = omr->messages[omr->msg_toget].param;
+    *hEvent = omr->messages[omr->msg_toget].hEvent;
+    omr->msg_toget = (omr->msg_toget + 1) % ALSA_RING_BUFFER_SIZE;
+    LeaveCriticalSection(&omr->msg_crst);
+    return 1;
+}
+
+/*======================================================================*
+ *                  Low level WAVE OUT implementation			*
+ *======================================================================*/
+
+
+/**************************************************************************
+ * 			wodNotifyClient			[internal]
+ */
+static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
+{
+    TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
+    
+    switch (wMsg) {
+    case WOM_OPEN:
+    case WOM_CLOSE:
+    case WOM_DONE:
+	if (wwo->wFlags != DCB_NULL && 
+	    !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, wwo->waveDesc.hWave, 
+			    wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
+	    WARN("can't notify client !\n");
+	    return MMSYSERR_ERROR;
+	}
+	break;
+    default:
+	FIXME("Unknown callback message %u\n", wMsg);
+        return MMSYSERR_INVALPARAM;
+    }
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodUpdatePlayedTotal	[internal]
+ *
+ */
+static BOOL wodUpdatePlayedTotal(WINE_WAVEOUT* wwo, snd_pcm_status_t* ps)
+{
+   return TRUE;
+}
+
+/**************************************************************************
+ * 				wodPlayer_BeginWaveHdr          [internal]
+ *
+ * Makes the specified lpWaveHdr the currently playing wave header.
+ * If the specified wave header is a begin loop and we're not already in
+ * a loop, setup the loop.
+ */
+static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
+{
+    wwo->lpPlayPtr = lpWaveHdr;
+
+    if (!lpWaveHdr) return;
+
+    wwo->lpPlayPtr->reserved = 0;
+
+    if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
+	if (wwo->lpLoopPtr) {
+	    WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
+	} else {
+	    TRACE("Starting loop (%ldx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
+	    wwo->lpLoopPtr = lpWaveHdr;
+	    /* Windows does not touch WAVEHDR.dwLoops,
+	     * so we need to make an internal copy */
+	    wwo->dwLoops = lpWaveHdr->dwLoops;
+	}
+    }
+}
+
+/**************************************************************************
+ * 				wodPlayer_PlayPtrNext	        [internal]
+ *
+ * Advance the play pointer to the next waveheader, looping if required.
+ */
+static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEOUT* wwo)
+{
+    LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
+
+    if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
+	/* We're at the end of a loop, loop if required */
+	if (--wwo->dwLoops > 0) {
+	    wwo->lpPlayPtr = wwo->lpLoopPtr;
+	    wwo->lpPlayPtr->reserved = 0;
+	} else {
+	    /* Handle overlapping loops correctly */
+	    if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
+		FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
+		/* shall we consider the END flag for the closing loop or for
+		 * the opening one or for both ???
+		 * code assumes for closing loop only
+		 */
+	    } else {
+                lpWaveHdr = lpWaveHdr->lpNext;
+            }
+            wwo->lpLoopPtr = NULL;
+            wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
+	}
+    } else {
+	/* We're not in a loop.  Advance to the next wave header */
+	wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
+    }
+
+    return lpWaveHdr;
+}
+
+/**************************************************************************
+ * 			     wodPlayer_DSPWait			[internal]
+ * Returns the number of milliseconds to wait for the DSP buffer to play a 
+ * period
+ */
+static DWORD wodPlayer_DSPWait(const WINE_WAVEOUT *wwo)
+{
+    /* time for one period to be played */
+    return snd_pcm_hw_params_get_period_time(wwo->hw_params, 0) / 1000;
+}
+
+/**************************************************************************
+ * 			     wodPllayer_NotifyWait               [internal]
+ * Returns the number of milliseconds to wait before attempting to notify
+ * completion of the specified wavehdr.
+ * This is based on the number of bytes remaining to be written in the
+ * wave.
+ */
+static DWORD wodPlayer_NotifyWait(const WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
+{
+    DWORD dwMillis;
+
+    dwMillis = (lpWaveHdr->dwBufferLength - lpWaveHdr->reserved) * 1000 / wwo->format.wf.nAvgBytesPerSec;
+    if (!dwMillis) dwMillis = 1;
+
+    return dwMillis;
+}
+
+
+/**************************************************************************
+ * 			     wodPlayer_WriteMaxFrags            [internal]
+ * Writes the maximum number of frames possible to the DSP and returns
+ * the number of frames written.
+ */
+static int wodPlayer_WriteMaxFrags(WINE_WAVEOUT* wwo, DWORD* frames)
+{
+    /* Only attempt to write to free frames */
+    LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
+    DWORD dwLength = snd_pcm_bytes_to_frames(wwo->p_handle, lpWaveHdr->dwBufferLength - lpWaveHdr->reserved);
+    int toWrite = min(dwLength, *frames);
+    int written;
+    
+    TRACE("Writing wavehdr %p.%lu[%lu]\n", lpWaveHdr, lpWaveHdr->reserved, lpWaveHdr->dwBufferLength);
+
+    written = (wwo->write)(wwo->p_handle, lpWaveHdr->lpData + lpWaveHdr->reserved, toWrite);
+    if ( written < 0)
+    {
+    	/* XRUN occurred. let's try to recover */
+        ALSA_XRUNRecovery(wwo, written);
+	written = (wwo->write)(wwo->p_handle, lpWaveHdr->lpData + lpWaveHdr->reserved, toWrite);
+    }
+    if (written <= 0)
+    {
+        /* still in error */
+        ERR("Error in writing wavehdr. Reason: %s\n", snd_strerror(written));
+        return written;
+    }
+
+    lpWaveHdr->reserved += snd_pcm_frames_to_bytes(wwo->p_handle, written);
+    if ( lpWaveHdr->reserved >= lpWaveHdr->dwBufferLength) {
+	/* this will be used to check if the given wave header has been fully played or not... */
+        lpWaveHdr->reserved = lpWaveHdr->dwBufferLength;
+        /* If we wrote all current wavehdr, skip to the next one */
+        wodPlayer_PlayPtrNext(wwo);
+    }
+    *frames -= written;
+    wwo->dwPlayedTotal += snd_pcm_frames_to_bytes(wwo->p_handle, written);
+
+    return written;
+}
+
+
+/**************************************************************************
+ * 				wodPlayer_NotifyCompletions	[internal]
+ *
+ * Notifies and remove from queue all wavehdrs which have been played to
+ * the speaker (ie. they have cleared the ALSA buffer).  If force is true,
+ * we notify all wavehdrs and remove them all from the queue even if they
+ * are unplayed or part of a loop.
+ */
+static DWORD wodPlayer_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
+{
+    LPWAVEHDR		lpWaveHdr;
+
+    /* Start from lpQueuePtr and keep notifying until:
+     * - we hit an unwritten wavehdr
+     * - we hit the beginning of a running loop
+     * - we hit a wavehdr which hasn't finished playing
+     */
+    while ((lpWaveHdr = wwo->lpQueuePtr) && 
+           (force || 
+            (lpWaveHdr != wwo->lpPlayPtr &&
+             lpWaveHdr != wwo->lpLoopPtr &&
+             lpWaveHdr->reserved == lpWaveHdr->dwBufferLength))) {
+
+	wwo->lpQueuePtr = lpWaveHdr->lpNext;
+
+	lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
+	lpWaveHdr->dwFlags |= WHDR_DONE;
+
+	wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
+    }
+    return  (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != wwo->lpLoopPtr) ? 
+        wodPlayer_NotifyWait(wwo, lpWaveHdr) : INFINITE;
+}
+
+/**************************************************************************
+ * 				wodPlayer_Reset			[internal]
+ *
+ * wodPlayer helper. Resets current output stream.
+ */
+static	void	wodPlayer_Reset(WINE_WAVEOUT* wwo)
+{
+    enum win_wm_message	msg;
+    DWORD		        param;
+    HANDLE		        ev;
+    int                         err;
+
+    /* updates current notify list */
+    wodPlayer_NotifyCompletions(wwo, FALSE);
+
+    if ( (err = snd_pcm_drop(wwo->p_handle)) < 0) {
+	FIXME("flush: %s\n", snd_strerror(err));
+	wwo->hThread = 0;
+	wwo->state = WINE_WS_STOPPED;
+	ExitThread(-1);
+    }
+    if ( (err = snd_pcm_prepare(wwo->p_handle)) < 0 )
+        ERR("pcm prepare failed: %s\n", snd_strerror(err));
+
+    /* remove any buffer */
+    wodPlayer_NotifyCompletions(wwo, TRUE);
+
+    wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
+    wwo->state = WINE_WS_STOPPED;
+
+    /* remove any existing message in the ring */
+    EnterCriticalSection(&wwo->msgRing.msg_crst);
+    /* return all pending headers in queue */
+    while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev))
+    {
+        if (msg != WINE_WM_HEADER) 
+        {
+            FIXME("shouldn't have headers left\n");
+            SetEvent(ev);
+            continue;
+        }
+        ((LPWAVEHDR)param)->dwFlags &= ~WHDR_INQUEUE;
+        ((LPWAVEHDR)param)->dwFlags |= WHDR_DONE;
+
+        wodNotifyClient(wwo, WOM_DONE, param, 0);
+    }
+    ResetEvent(wwo->msgRing.msg_event);
+    LeaveCriticalSection(&wwo->msgRing.msg_crst);
+}
+
+/**************************************************************************
+ * 		      wodPlayer_ProcessMessages			[internal]
+ */
+static void wodPlayer_ProcessMessages(WINE_WAVEOUT* wwo)
+{
+    LPWAVEHDR           lpWaveHdr;
+    enum win_wm_message	msg;
+    DWORD		param;
+    HANDLE		ev;
+    int                 err;
+
+    while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev)) {
+    /* TRACE("Received %s %lx\n", wodPlayerCmdString[msg - WM_USER - 1], param); */
+
+	switch (msg) {
+	case WINE_WM_PAUSING:
+	    if ( snd_pcm_state(wwo->p_handle) == SND_PCM_STATE_RUNNING )
+	     {
+		err = snd_pcm_pause(wwo->p_handle, 1);
+		if ( err < 0 )
+		    ERR("pcm_pause failed: %s\n", snd_strerror(err));
+	     }
+	    wwo->state = WINE_WS_PAUSED;
+	    SetEvent(ev);
+	    break;
+	case WINE_WM_RESTARTING:
+            if (wwo->state == WINE_WS_PAUSED)
+            {
+		if ( snd_pcm_state(wwo->p_handle) == SND_PCM_STATE_PAUSED )
+		 {
+		    err = snd_pcm_pause(wwo->p_handle, 0);
+		    if ( err < 0 )
+		        ERR("pcm_pause failed: %s\n", snd_strerror(err));
+		 }
+                wwo->state = WINE_WS_PLAYING;
+            } 
+	    SetEvent(ev);
+	    break;
+	case WINE_WM_HEADER:
+	    lpWaveHdr = (LPWAVEHDR)param;
+	    
+	    /* insert buffer at the end of queue */
+	    {
+		LPWAVEHDR*	wh;
+		for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
+		*wh = lpWaveHdr;
+	    }
+            if (!wwo->lpPlayPtr)
+                wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
+	    if (wwo->state == WINE_WS_STOPPED)
+		wwo->state = WINE_WS_PLAYING;
+	    break;
+	case WINE_WM_RESETTING:
+	    wodPlayer_Reset(wwo);
+	    SetEvent(ev);
+	    break;
+        case WINE_WM_UPDATE:
+            wodUpdatePlayedTotal(wwo, NULL);
+	    SetEvent(ev);
+            break;
+        case WINE_WM_BREAKLOOP:
+            if (wwo->state == WINE_WS_PLAYING && wwo->lpLoopPtr != NULL) {
+                /* ensure exit at end of current loop */
+                wwo->dwLoops = 1;
+            }
+	    SetEvent(ev);
+            break;
+	case WINE_WM_CLOSING:
+	    /* sanity check: this should not happen since the device must have been reset before */
+	    if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
+	    wwo->hThread = 0;
+	    wwo->state = WINE_WS_CLOSED;
+	    SetEvent(ev);
+	    ExitThread(0);
+	    /* shouldn't go here */
+	default:
+	    FIXME("unknown message %d\n", msg);
+	    break;
+	}
+    }
+}
+
+/**************************************************************************
+ * 			     wodPlayer_FeedDSP			[internal]
+ * Feed as much sound data as we can into the DSP and return the number of
+ * milliseconds before it will be necessary to feed the DSP again.
+ */
+static DWORD wodPlayer_FeedDSP(WINE_WAVEOUT* wwo)
+{
+    DWORD               availInQ = snd_pcm_avail_update(wwo->p_handle);
+
+    /* no more room... no need to try to feed */
+    while (wwo->lpPlayPtr && availInQ > 0)
+        if ( wodPlayer_WriteMaxFrags(wwo, &availInQ) < 0 )
+	    break;
+
+    return wodPlayer_DSPWait(wwo);
+}
+
+/**************************************************************************
+ * 				wodPlayer			[internal]
+ */
+static	DWORD	CALLBACK	wodPlayer(LPVOID pmt)
+{
+    WORD	  uDevID = (DWORD)pmt;
+    WINE_WAVEOUT* wwo = (WINE_WAVEOUT*)&WOutDev[uDevID];
+    DWORD         dwNextFeedTime = INFINITE;   /* Time before DSP needs feeding */
+    DWORD         dwNextNotifyTime = INFINITE; /* Time before next wave completion */
+    DWORD         dwSleepTime;
+
+    wwo->state = WINE_WS_STOPPED;
+    SetEvent(wwo->hStartUpEvent);
+
+    for (;;) {
+        /** Wait for the shortest time before an action is required.  If there
+         *  are no pending actions, wait forever for a command.
+         */
+        dwSleepTime = min(dwNextFeedTime, dwNextNotifyTime);
+        TRACE("waiting %lums (%lu,%lu)\n", dwSleepTime, dwNextFeedTime, dwNextNotifyTime);
+        WaitForSingleObject(wwo->msgRing.msg_event, dwSleepTime);
+	wodPlayer_ProcessMessages(wwo);
+	if (wwo->state == WINE_WS_PLAYING) {
+	    dwNextFeedTime = wodPlayer_FeedDSP(wwo);
+	    dwNextNotifyTime = wodPlayer_NotifyCompletions(wwo, FALSE);
+	} else {
+	    dwNextFeedTime = dwNextNotifyTime = INFINITE;
+	}
+    }
+}
+
+/**************************************************************************
+ * 			wodGetDevCaps				[internal]
+ */
+static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSA lpCaps, DWORD dwSize)
+{
+    TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
+    
+    if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
+    
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	TRACE("MAX_WAVOUTDRV reached !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+
+    memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodOpen				[internal]
+ */
+static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
+{
+    WINE_WAVEOUT*	        wwo; 
+    snd_pcm_hw_params_t *       hw_params;
+    snd_pcm_sw_params_t *       sw_params;
+    snd_pcm_access_t            access;
+    snd_pcm_format_t            format;
+    int                         rate;
+    int                         buffer_size = 0x4000;  /* in frames (1 frame = sizeof(sample) * n.channels) */
+    int                         num_periods = 32;
+    snd_pcm_uframes_t           period_size;
+    int                         flags;
+    snd_pcm_t *                 pcm;
+    int                         err;
+
+    snd_pcm_hw_params_alloca(&hw_params);
+    snd_pcm_sw_params_alloca(&sw_params);
+
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
+    if (lpDesc == NULL) {
+	WARN("Invalid Parameter !\n");
+	return MMSYSERR_INVALPARAM;
+    }
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	TRACE("MAX_WAVOUTDRV reached !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+
+    /* only PCM format is supported so far... */
+    if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
+	lpDesc->lpFormat->nChannels == 0 ||
+	lpDesc->lpFormat->nSamplesPerSec == 0) {
+	WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n", 
+	     lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
+	     lpDesc->lpFormat->nSamplesPerSec);
+	return WAVERR_BADFORMAT;
+    }
+
+    if (dwFlags & WAVE_FORMAT_QUERY) {
+	TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n", 
+	     lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
+	     lpDesc->lpFormat->nSamplesPerSec);
+	return MMSYSERR_NOERROR;
+    }
+
+    wwo = &WOutDev[wDevID];
+
+    if ((dwFlags & WAVE_DIRECTSOUND) && !(wwo->caps.dwSupport & WAVECAPS_DIRECTSOUND))
+	/* not supported, ignore it */
+	dwFlags &= ~WAVE_DIRECTSOUND;
+
+    wwo->p_handle = 0;
+    flags = SND_PCM_NONBLOCK;
+    if ( dwFlags & WAVE_DIRECTSOUND )
+    	flags |= SND_PCM_ASYNC;
+
+    if (snd_pcm_open(&pcm, wwo->device, SND_PCM_STREAM_PLAYBACK, dwFlags))
+    {
+        ERR("Error open: %s\n", snd_strerror(errno)); 
+	return MMSYSERR_NOTENABLED;
+    }
+
+    wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
+    
+    memcpy(&wwo->waveDesc, lpDesc, 	     sizeof(WAVEOPENDESC));
+    memcpy(&wwo->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
+    
+    if (wwo->format.wBitsPerSample == 0) {
+	WARN("Resetting zeroed wBitsPerSample\n");
+	wwo->format.wBitsPerSample = 8 *
+	    (wwo->format.wf.nAvgBytesPerSec /
+	     wwo->format.wf.nSamplesPerSec) /
+	    wwo->format.wf.nChannels;
+    }
+
+    snd_pcm_hw_params_any(pcm, hw_params);
+
+#define EXIT_ON_ERROR(f,e,txt) do \
+{ \
+    int err; \
+    if ( (err = (f) ) < 0) \
+    { \
+	ERR(txt ": %s\n", snd_strerror(err)); \
+	snd_pcm_close(pcm); \
+	return e; \
+    } \
+} while(0)
+
+    access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
+    if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
+        WARN("mmap not available. switching to standard write.\n");
+        access = SND_PCM_ACCESS_RW_INTERLEAVED;
+	EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
+	wwo->write = snd_pcm_writei;
+    }
+    else
+	wwo->write = snd_pcm_mmap_writei;
+
+    EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwo->format.wf.nChannels), MMSYSERR_INVALPARAM, "unable to set required channels");
+
+    format = (wwo->format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE : SND_PCM_FORMAT_U8;
+    EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), MMSYSERR_INVALPARAM, "unable to set required format");
+
+    EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_size_near(pcm, hw_params, buffer_size), MMSYSERR_NOMEM, "unable to get required buffer");
+    buffer_size = snd_pcm_hw_params_get_buffer_size(hw_params);
+
+    EXIT_ON_ERROR( snd_pcm_hw_params_set_period_size_near(pcm, hw_params, buffer_size/num_periods, 0), MMSYSERR_ERROR, "unable to set required period size");
+    period_size = snd_pcm_hw_params_get_period_size(hw_params, 0);
+
+    rate = snd_pcm_hw_params_set_rate_near(pcm, hw_params, wwo->format.wf.nSamplesPerSec, 0);
+    if (rate < 0) {
+	ERR("Rate %ld Hz not available for playback: %s\n", wwo->format.wf.nSamplesPerSec, snd_strerror(rate));
+	snd_pcm_close(pcm);
+        return WAVERR_BADFORMAT;
+    }
+    if (rate != wwo->format.wf.nSamplesPerSec) {
+	ERR("Rate doesn't match (requested %ld Hz, got %d Hz)\n", wwo->format.wf.nSamplesPerSec, rate);
+	snd_pcm_close(pcm);
+        return WAVERR_BADFORMAT;
+    }
+
+    EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
+
+    snd_pcm_sw_params_current(pcm, sw_params);
+    EXIT_ON_ERROR( snd_pcm_sw_params_set_start_threshold(pcm, sw_params, dwFlags & WAVE_DIRECTSOUND ? MAXINT : 1 ), MMSYSERR_ERROR, "unable to set start threshold");
+    EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, period_size*2), MMSYSERR_ERROR, "unable to set silence size");
+    EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
+    EXIT_ON_ERROR( snd_pcm_sw_params_set_xfer_align(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set xfer align");
+    EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
+    EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
+#undef EXIT_ON_ERROR
+
+    snd_pcm_prepare(pcm);
+
+    if (TRACE_ON(wave))
+	ALSA_TraceParameters(hw_params, sw_params, FALSE);
+
+    /* now, we can save all required data for later use... */
+    if ( wwo->hw_params )
+    	snd_pcm_hw_params_free(wwo->hw_params);
+    snd_pcm_hw_params_malloc(&(wwo->hw_params));
+    snd_pcm_hw_params_copy(wwo->hw_params, hw_params);
+
+    wwo->dwBufferSize = buffer_size;
+    wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
+    wwo->p_handle = pcm;
+
+    ALSA_InitRingMessage(&wwo->msgRing);
+
+    if (!(dwFlags & WAVE_DIRECTSOUND)) {
+	wwo->hStartUpEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+	wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD)wDevID, 0, &(wwo->dwThreadID));
+	WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
+	CloseHandle(wwo->hStartUpEvent);
+    } else {
+	wwo->hThread = INVALID_HANDLE_VALUE;
+	wwo->dwThreadID = 0;
+    }
+    wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
+
+    TRACE("handle=%08lx \n", (DWORD)wwo->p_handle);
+/*    if (wwo->dwFragmentSize % wwo->format.wf.nBlockAlign)
+	ERR("Fragment doesn't contain an integral number of data blocks\n");
+*/
+    TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n", 
+	  wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec, 
+	  wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
+	  wwo->format.wf.nBlockAlign);
+
+    return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
+}
+
+
+/**************************************************************************
+ * 				wodClose			[internal]
+ */
+static DWORD wodClose(WORD wDevID)
+{
+    DWORD		ret = MMSYSERR_NOERROR;
+    WINE_WAVEOUT*	wwo;
+
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    wwo = &WOutDev[wDevID];
+    if (wwo->lpQueuePtr) {
+	WARN("buffers still playing !\n");
+	ret = WAVERR_STILLPLAYING;
+    } else {
+	if (wwo->hThread != INVALID_HANDLE_VALUE) {
+	    ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_CLOSING, 0, TRUE);
+	}
+        ALSA_DestroyRingMessage(&wwo->msgRing);
+
+	snd_pcm_hw_params_free(wwo->hw_params);
+	wwo->hw_params = NULL;
+
+        snd_pcm_close(wwo->p_handle);
+	wwo->p_handle = NULL;
+	
+	ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
+    }
+    return ret;
+}
+
+
+/**************************************************************************
+ * 				wodWrite			[internal]
+ * 
+ */
+static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
+    
+    /* first, do the sanity checks... */
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+        WARN("bad dev ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED)) 
+	return WAVERR_UNPREPARED;
+    
+    if (lpWaveHdr->dwFlags & WHDR_INQUEUE) 
+	return WAVERR_STILLPLAYING;
+
+    lpWaveHdr->dwFlags &= ~WHDR_DONE;
+    lpWaveHdr->dwFlags |= WHDR_INQUEUE;
+    lpWaveHdr->lpNext = 0;
+
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
+
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodPrepare			[internal]
+ */
+static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
+    
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
+	return WAVERR_STILLPLAYING;
+    
+    lpWaveHdr->dwFlags |= WHDR_PREPARED;
+    lpWaveHdr->dwFlags &= ~WHDR_DONE;
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodUnprepare			[internal]
+ */
+static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
+    
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
+	return WAVERR_STILLPLAYING;
+    
+    lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
+    lpWaveHdr->dwFlags |= WHDR_DONE;
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 			wodPause				[internal]
+ */
+static DWORD wodPause(WORD wDevID)
+{
+    TRACE("(%u);!\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_PAUSING, 0, TRUE);
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 			wodRestart				[internal]
+ */
+static DWORD wodRestart(WORD wDevID)
+{
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (WOutDev[wDevID].state == WINE_WS_PAUSED) {
+	ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESTARTING, 0, TRUE);
+    }
+    
+    /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
+    /* FIXME: Myst crashes with this ... hmm -MM
+       return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
+    */
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 			wodReset				[internal]
+ */
+static DWORD wodReset(WORD wDevID)
+{
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodGetPosition			[internal]
+ */
+static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
+{
+    int			time;
+    DWORD		val;
+    WINE_WAVEOUT*	wwo;
+
+    TRACE("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpTime == NULL)	return MMSYSERR_INVALPARAM;
+
+    wwo = &WOutDev[wDevID];
+    ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_UPDATE, 0, TRUE);
+    val = wwo->dwPlayedTotal;
+
+    TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%lu nChannels=%u nAvgBytesPerSec=%lu\n", 
+	  lpTime->wType, wwo->format.wBitsPerSample, 
+	  wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels, 
+	  wwo->format.wf.nAvgBytesPerSec); 
+    TRACE("dwPlayedTotal=%lu\n", val);
+    
+    switch (lpTime->wType) {
+    case TIME_BYTES:
+	lpTime->u.cb = val;
+	TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
+	break;
+    case TIME_SAMPLES:
+	lpTime->u.sample = val * 8 / wwo->format.wBitsPerSample /wwo->format.wf.nChannels;
+	TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
+	break;
+    case TIME_SMPTE:
+	time = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
+	lpTime->u.smpte.hour = time / 108000;
+	time -= lpTime->u.smpte.hour * 108000;
+	lpTime->u.smpte.min = time / 1800;
+	time -= lpTime->u.smpte.min * 1800;
+	lpTime->u.smpte.sec = time / 30;
+	time -= lpTime->u.smpte.sec * 30;
+	lpTime->u.smpte.frame = time;
+	lpTime->u.smpte.fps = 30;
+	TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
+	      lpTime->u.smpte.hour, lpTime->u.smpte.min,
+	      lpTime->u.smpte.sec, lpTime->u.smpte.frame);
+	break;
+    default:
+	FIXME("Format %d not supported ! use TIME_MS !\n", lpTime->wType);
+	lpTime->wType = TIME_MS;
+    case TIME_MS:
+	lpTime->u.ms = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
+	TRACE("TIME_MS=%lu\n", lpTime->u.ms);
+	break;
+    }
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodBreakLoop			[internal]
+ */
+static DWORD wodBreakLoop(WORD wDevID)
+{
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_BREAKLOOP, 0, TRUE);
+    return MMSYSERR_NOERROR;
+}
+    
+/**************************************************************************
+ * 				wodGetVolume			[internal]
+ */
+static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
+{
+    WORD	       left, right;
+    WINE_WAVEOUT*      wwo;
+    int                count;
+    long               min, max;
+
+    TRACE("(%u, %p);\n", wDevID, lpdwVol);
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    wwo = &WOutDev[wDevID];
+    count = snd_ctl_elem_info_get_count(wwo->playback_einfo);
+    min = snd_ctl_elem_info_get_min(wwo->playback_einfo);
+    max = snd_ctl_elem_info_get_max(wwo->playback_einfo);
+
+#define VOLUME_ALSA_TO_WIN(x) (((x)-min) * 65536 /(max-min))
+    if (lpdwVol == NULL) 
+	return MMSYSERR_NOTENABLED;
+
+    switch (count)
+    {
+   	case 2:
+	    left = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 0));
+	    right = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 1));
+	    break;
+	case 1:
+	    left = right = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 0));
+	    break;
+	default:
+	    WARN("%d channels mixer not supported\n", count);
+	    return MMSYSERR_NOERROR;
+     }
+#undef VOLUME_ALSA_TO_WIN
+
+    TRACE("left=%d right=%d !\n", left, right);
+    *lpdwVol = MAKELONG( left, right );
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodSetVolume			[internal]
+ */
+static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
+{
+    WORD	       left, right;
+    WINE_WAVEOUT*      wwo;
+    int                count, err;
+    long               min, max;
+
+    TRACE("(%u, %08lX);\n", wDevID, dwParam);
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    wwo = &WOutDev[wDevID];
+    count=snd_ctl_elem_info_get_count(wwo->playback_einfo);
+    min = snd_ctl_elem_info_get_min(wwo->playback_einfo);
+    max = snd_ctl_elem_info_get_max(wwo->playback_einfo);
+
+    left  = LOWORD(dwParam);
+    right = HIWORD(dwParam);
+
+#define VOLUME_WIN_TO_ALSA(x) ( (((x) * (max-min)) / 65536) + min )
+    switch (count)
+    {
+   	case 2:
+	    snd_ctl_elem_value_set_integer(wwo->playback_evalue, 0, VOLUME_WIN_TO_ALSA(left));
+	    snd_ctl_elem_value_set_integer(wwo->playback_evalue, 1, VOLUME_WIN_TO_ALSA(right));
+	    break;
+	case 1:
+	    snd_ctl_elem_value_set_integer(wwo->playback_evalue, 0, VOLUME_WIN_TO_ALSA(left));
+	    break;
+	default:
+	    WARN("%d channels mixer not supported\n", count);
+     }
+#undef VOLUME_WIN_TO_ALSA
+    if ( (err = snd_ctl_elem_write(wwo->ctl, wwo->playback_evalue)) < 0)
+    {
+	ERR("error writing snd_ctl_elem_value: %s\n", snd_strerror(err));
+    }
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodGetNumDevs			[internal]
+ */
+static	DWORD	wodGetNumDevs(void)
+{
+    return ALSA_WodNumDevs;
+}
+
+
+/**************************************************************************
+ * 				wodMessage (WINEALSA.7)
+ */
+DWORD WINAPI ALSA_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser, 
+                             DWORD dwParam1, DWORD dwParam2)
+{
+    TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
+	  wDevID, wMsg, dwUser, dwParam1, dwParam2);
+    
+    switch (wMsg) {
+    case DRVM_INIT:
+    case DRVM_EXIT:
+    case DRVM_ENABLE:
+    case DRVM_DISABLE:
+	/* FIXME: Pretend this is supported */
+	return 0;
+    case WODM_OPEN:	 	return wodOpen		(wDevID, (LPWAVEOPENDESC)dwParam1,	dwParam2);
+    case WODM_CLOSE:	 	return wodClose		(wDevID);
+    case WODM_GETDEVCAPS:	return wodGetDevCaps	(wDevID, (LPWAVEOUTCAPSA)dwParam1,	dwParam2);
+    case WODM_GETNUMDEVS:	return wodGetNumDevs	();
+    case WODM_GETPITCH:	 	return MMSYSERR_NOTSUPPORTED;
+    case WODM_SETPITCH:	 	return MMSYSERR_NOTSUPPORTED;
+    case WODM_GETPLAYBACKRATE:	return MMSYSERR_NOTSUPPORTED;
+    case WODM_SETPLAYBACKRATE:	return MMSYSERR_NOTSUPPORTED;
+    case WODM_WRITE:	 	return wodWrite		(wDevID, (LPWAVEHDR)dwParam1,		dwParam2);
+    case WODM_PAUSE:	 	return wodPause		(wDevID);
+    case WODM_GETPOS:	 	return wodGetPosition	(wDevID, (LPMMTIME)dwParam1, 		dwParam2);
+    case WODM_BREAKLOOP: 	return wodBreakLoop     (wDevID);
+    case WODM_PREPARE:	 	return wodPrepare	(wDevID, (LPWAVEHDR)dwParam1, 		dwParam2);
+    case WODM_UNPREPARE: 	return wodUnprepare	(wDevID, (LPWAVEHDR)dwParam1, 		dwParam2);
+    case WODM_GETVOLUME:	return wodGetVolume	(wDevID, (LPDWORD)dwParam1);
+    case WODM_SETVOLUME:	return wodSetVolume	(wDevID, dwParam1);
+    case WODM_RESTART:		return wodRestart	(wDevID);
+    case WODM_RESET:		return wodReset		(wDevID);
+    case DRV_QUERYDSOUNDIFACE:	return wodDsCreate(wDevID, (PIDSDRIVER*)dwParam1);
+    default:
+	FIXME("unknown message %d!\n", wMsg);
+    }
+    return MMSYSERR_NOTSUPPORTED;
+}
+
+/*======================================================================*
+ *                  Low level DSOUND implementation			*
+ *======================================================================*/
+
+typedef struct IDsDriverImpl IDsDriverImpl;
+typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
+
+struct IDsDriverImpl
+{
+    /* IUnknown fields */
+    ICOM_VFIELD(IDsDriver);
+    DWORD		ref;
+    /* IDsDriverImpl fields */
+    UINT		wDevID;
+    IDsDriverBufferImpl*primary;
+};
+
+struct IDsDriverBufferImpl
+{
+    /* IUnknown fields */
+    ICOM_VFIELD(IDsDriverBuffer);
+    DWORD		      ref;
+    /* IDsDriverBufferImpl fields */
+    IDsDriverImpl*	      drv;
+
+    CRITICAL_SECTION          mmap_crst;
+    LPVOID                    mmap_buffer;
+    DWORD                     mmap_buflen_bytes;
+    snd_pcm_uframes_t         mmap_buflen_frames;
+    snd_pcm_channel_area_t *  mmap_areas;
+    snd_async_handler_t *     mmap_async_handler;
+};
+
+static void DSDB_CheckXRUN(IDsDriverBufferImpl* pdbi)
+{
+    WINE_WAVEOUT *     wwo = &(WOutDev[pdbi->drv->wDevID]);
+    snd_pcm_state_t    state = snd_pcm_state(wwo->p_handle);
+
+    if ( state == SND_PCM_STATE_XRUN )
+    {
+	int            err = snd_pcm_prepare(wwo->p_handle);
+	TRACE("xrun occurred\n");
+	if ( err < 0 )
+            ERR("recovery from xrun failed, prepare failed: %s\n", snd_strerror(err));
+    }
+    else if ( state == SND_PCM_STATE_SUSPENDED )
+    {
+	int            err = snd_pcm_resume(wwo->p_handle);
+	TRACE("recovery from suspension occurred\n");
+        if (err < 0 && err != -EAGAIN){
+            err = snd_pcm_prepare(wwo->p_handle);
+            if (err < 0)
+                ERR("recovery from suspend failed, prepare failed: %s\n", snd_strerror(err));
+        }
+    }
+}
+
+static void DSDB_MMAPCopy(IDsDriverBufferImpl* pdbi)
+{
+    WINE_WAVEOUT *     wwo = &(WOutDev[pdbi->drv->wDevID]);
+    int                channels;
+    snd_pcm_format_t   format;
+    snd_pcm_uframes_t  period_size;
+    snd_pcm_sframes_t  avail;
+    snd_pcm_state_t    state;
+
+    if ( !pdbi->mmap_buffer || !wwo->hw_params || !wwo->p_handle)
+    	return;
+
+    channels = snd_pcm_hw_params_get_channels(wwo->hw_params);
+    format = snd_pcm_hw_params_get_format(wwo->hw_params);
+    period_size = snd_pcm_hw_params_get_period_size(wwo->hw_params, 0);
+    avail = snd_pcm_avail_update(wwo->p_handle);
+
+    DSDB_CheckXRUN(pdbi);
+
+    TRACE("avail=%d format=%s channels=%d\n", (int)avail, snd_pcm_format_name(format), channels );
+
+    while (avail >= period_size)
+    {
+	const snd_pcm_channel_area_t *areas;
+	snd_pcm_uframes_t     ofs;
+	snd_pcm_uframes_t     frames;
+	int                   err;
+
+	frames = avail / period_size * period_size; /* round down to a multiple of period_size */
+
+	EnterCriticalSection(&pdbi->mmap_crst);
+
+	snd_pcm_mmap_begin(wwo->p_handle, &areas, &ofs, &frames);
+	snd_pcm_areas_copy(areas, ofs, pdbi->mmap_areas, ofs, channels, frames, format);
+	err = snd_pcm_mmap_commit(wwo->p_handle, ofs, frames);
+
+	LeaveCriticalSection(&pdbi->mmap_crst);
+
+	if ( err != (snd_pcm_sframes_t) frames)
+	    ERR("mmap partially failed.\n");
+
+	avail = snd_pcm_avail_update(wwo->p_handle);
+    }
+ }
+
+static void DSDB_PCMCallback(snd_async_handler_t *ahandler)
+{
+    /* snd_pcm_t *               handle = snd_async_handler_get_pcm(ahandler); */
+    IDsDriverBufferImpl*      pdbi = snd_async_handler_get_callback_private(ahandler);
+    TRACE("callback called\n");
+    DSDB_MMAPCopy(pdbi);
+}
+
+static int DSDB_CreateMMAP(IDsDriverBufferImpl* pdbi)
+ {
+    WINE_WAVEOUT *            wwo = &(WOutDev[pdbi->drv->wDevID]);
+    snd_pcm_format_t          format = snd_pcm_hw_params_get_format(wwo->hw_params);
+    snd_pcm_uframes_t         frames = snd_pcm_hw_params_get_buffer_size(wwo->hw_params);
+    int                       channels = snd_pcm_hw_params_get_channels(wwo->hw_params);
+    unsigned int              bits_per_sample = snd_pcm_format_physical_width(format);
+    unsigned int              bits_per_frame = bits_per_sample * channels;
+    snd_pcm_channel_area_t *  a;
+    unsigned int              c;
+    int                       err;
+
+    if (TRACE_ON(wave))
+	ALSA_TraceParameters(wwo->hw_params, NULL, FALSE);
+
+    TRACE("format=%s  frames=%ld  channels=%d  bits_per_sample=%d  bits_per_frame=%d\n",
+          snd_pcm_format_name(format), frames, channels, bits_per_sample, bits_per_frame);
+
+    pdbi->mmap_buflen_frames = frames;
+    pdbi->mmap_buflen_bytes = snd_pcm_frames_to_bytes( wwo->p_handle, frames );
+    pdbi->mmap_buffer = HeapAlloc(GetProcessHeap(),0,pdbi->mmap_buflen_bytes);
+    if (!pdbi->mmap_buffer)
+	return DSERR_OUTOFMEMORY;
+
+    snd_pcm_format_set_silence(format, pdbi->mmap_buffer, frames );
+
+    TRACE("created mmap buffer of %ld frames (%ld bytes) at %p\n",
+        frames, pdbi->mmap_buflen_bytes, pdbi->mmap_buffer);
+
+    pdbi->mmap_areas = HeapAlloc(GetProcessHeap(),0,channels*sizeof(snd_pcm_channel_area_t));
+    if (!pdbi->mmap_areas)
+	return DSERR_OUTOFMEMORY;
+
+    a = pdbi->mmap_areas;
+    for (c = 0; c < channels; c++, a++)
+    {
+	a->addr = pdbi->mmap_buffer;
+	a->first = bits_per_sample * c;
+	a->step = bits_per_frame;
+	TRACE("Area %d: addr=%p  first=%d  step=%d\n", c, a->addr, a->first, a->step);
+    }
+
+    InitializeCriticalSection(&pdbi->mmap_crst);
+
+    err = snd_async_add_pcm_handler(&pdbi->mmap_async_handler, wwo->p_handle, DSDB_PCMCallback, pdbi);
+    if ( err < 0 )
+     {
+ 	ERR("add_pcm_handler failed. reason: %s\n", snd_strerror(err));
+	return DSERR_GENERIC;
+     }
+
+    return DS_OK;
+ }
+
+static void DSDB_DestroyMMAP(IDsDriverBufferImpl* pdbi)
+{
+    TRACE("mmap buffer %p destroyed\n", pdbi->mmap_buffer);
+    HeapFree(GetProcessHeap(), 0, pdbi->mmap_areas);
+    HeapFree(GetProcessHeap(), 0, pdbi->mmap_buffer);
+    pdbi->mmap_areas = NULL;
+    pdbi->mmap_buffer = NULL;
+    DeleteCriticalSection(&pdbi->mmap_crst);
+}
+
+
+static HRESULT WINAPI IDsDriverBufferImpl_QueryInterface(PIDSDRIVERBUFFER iface, REFIID riid, LPVOID *ppobj)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    FIXME("(): stub!\n");
+    return DSERR_UNSUPPORTED;
+}
+
+static ULONG WINAPI IDsDriverBufferImpl_AddRef(PIDSDRIVERBUFFER iface)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    TRACE("(%p)\n",iface);
+    return ++This->ref;
+}
+
+static ULONG WINAPI IDsDriverBufferImpl_Release(PIDSDRIVERBUFFER iface)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    TRACE("(%p)\n",iface);
+    if (--This->ref)
+	return This->ref;
+    if (This == This->drv->primary)
+	This->drv->primary = NULL;
+    DSDB_DestroyMMAP(This);
+    HeapFree(GetProcessHeap(), 0, This);
+    return 0;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Lock(PIDSDRIVERBUFFER iface,
+					       LPVOID*ppvAudio1,LPDWORD pdwLen1,
+					       LPVOID*ppvAudio2,LPDWORD pdwLen2,
+					       DWORD dwWritePosition,DWORD dwWriteLen,
+					       DWORD dwFlags)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    TRACE("(%p)\n",iface);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Unlock(PIDSDRIVERBUFFER iface,
+						 LPVOID pvAudio1,DWORD dwLen1,
+						 LPVOID pvAudio2,DWORD dwLen2)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    TRACE("(%p)\n",iface);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetFormat(PIDSDRIVERBUFFER iface,
+						    LPWAVEFORMATEX pwfx)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    TRACE("(%p,%p)\n",iface,pwfx);
+    return DSERR_BUFFERLOST;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetFrequency(PIDSDRIVERBUFFER iface, DWORD dwFreq)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    TRACE("(%p,%ld): stub\n",iface,dwFreq);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetVolumePan(PIDSDRIVERBUFFER iface, PDSVOLUMEPAN pVolPan)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    FIXME("(%p,%p): stub!\n",iface,pVolPan);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetPosition(PIDSDRIVERBUFFER iface, DWORD dwNewPos)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    TRACE("(%p,%ld): stub\n",iface,dwNewPos);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_GetPosition(PIDSDRIVERBUFFER iface,
+						      LPDWORD lpdwPlay, LPDWORD lpdwWrite)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    WINE_WAVEOUT *      wwo = &(WOutDev[This->drv->wDevID]);
+    snd_pcm_uframes_t   hw_ptr;
+    snd_pcm_uframes_t   period_size = snd_pcm_hw_params_get_period_size(wwo->hw_params, 0);
+
+    /** we need to track down buffer underruns */
+    DSDB_CheckXRUN(This);
+
+    EnterCriticalSection(&This->mmap_crst);
+    hw_ptr = _snd_pcm_mmap_hw_ptr(wwo->p_handle);
+    if (lpdwPlay)
+	*lpdwPlay = snd_pcm_frames_to_bytes(wwo->p_handle, hw_ptr/ period_size  * period_size) % This->mmap_buflen_bytes;
+    if (lpdwWrite)
+	*lpdwWrite = snd_pcm_frames_to_bytes(wwo->p_handle, (hw_ptr / period_size + 1) * period_size ) % This->mmap_buflen_bytes;
+    LeaveCriticalSection(&This->mmap_crst);
+    
+    TRACE("hw_ptr=0x%08x, playpos=%ld, writepos=%ld\n", (unsigned int)hw_ptr, lpdwPlay?*lpdwPlay:-1, lpdwWrite?*lpdwWrite:-1);
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Play(PIDSDRIVERBUFFER iface, DWORD dwRes1, DWORD dwRes2, DWORD dwFlags)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    WINE_WAVEOUT *       wwo = &(WOutDev[This->drv->wDevID]);
+    snd_pcm_state_t      state;
+    int                  err;
+
+    TRACE("(%p,%lx,%lx,%lx)\n",iface,dwRes1,dwRes2,dwFlags);
+
+    state = snd_pcm_state(wwo->p_handle);
+    if ( state == SND_PCM_STATE_SETUP )
+    {
+	err = snd_pcm_prepare(wwo->p_handle);
+        state = snd_pcm_state(wwo->p_handle);
+    }
+    if ( state == SND_PCM_STATE_PREPARED )
+     {
+	DSDB_MMAPCopy(This);
+	err = snd_pcm_start(wwo->p_handle);
+     }
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Stop(PIDSDRIVERBUFFER iface)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    WINE_WAVEOUT *    wwo = &(WOutDev[This->drv->wDevID]);
+    int               err;
+    DWORD             play;
+    DWORD             write;
+
+    TRACE("(%p)\n",iface);
+
+    /* ring buffer wrap up detection */
+    IDsDriverBufferImpl_GetPosition(iface, &play, &write);
+    if ( play > write)
+    {
+	TRACE("writepos wrapper up\n");
+    	return DS_OK;
+    }
+
+    if ( ( err = snd_pcm_drop(wwo->p_handle)) < 0 )
+    {
+   	ERR("error while stopping pcm: %s\n", snd_strerror(err));
+	return DSERR_GENERIC;
+    }
+    return DS_OK;
+}
+
+static ICOM_VTABLE(IDsDriverBuffer) dsdbvt =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    IDsDriverBufferImpl_QueryInterface,
+    IDsDriverBufferImpl_AddRef,
+    IDsDriverBufferImpl_Release,
+    IDsDriverBufferImpl_Lock,
+    IDsDriverBufferImpl_Unlock,
+    IDsDriverBufferImpl_SetFormat,
+    IDsDriverBufferImpl_SetFrequency,
+    IDsDriverBufferImpl_SetVolumePan,
+    IDsDriverBufferImpl_SetPosition,
+    IDsDriverBufferImpl_GetPosition,
+    IDsDriverBufferImpl_Play,
+    IDsDriverBufferImpl_Stop
+};
+
+static HRESULT WINAPI IDsDriverImpl_QueryInterface(PIDSDRIVER iface, REFIID riid, LPVOID *ppobj)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    FIXME("(%p): stub!\n",iface);
+    return DSERR_UNSUPPORTED;
+}
+
+static ULONG WINAPI IDsDriverImpl_AddRef(PIDSDRIVER iface)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    TRACE("(%p)\n",iface);
+    This->ref++;
+    return This->ref;
+}
+
+static ULONG WINAPI IDsDriverImpl_Release(PIDSDRIVER iface)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    TRACE("(%p)\n",iface);
+    if (--This->ref)
+	return This->ref;
+    HeapFree(GetProcessHeap(),0,This);
+    return 0;
+}
+
+static HRESULT WINAPI IDsDriverImpl_GetDriverDesc(PIDSDRIVER iface, PDSDRIVERDESC pDesc)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    TRACE("(%p,%p)\n",iface,pDesc);
+    pDesc->dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT |
+	DSDDESC_USESYSTEMMEMORY;
+    strcpy(pDesc->szDesc, "WineALSA DirectSound Driver");
+    strcpy(pDesc->szDrvName, "winealsa.drv");
+    pDesc->dnDevNode		= WOutDev[This->wDevID].waveDesc.dnDevNode;
+    pDesc->wVxdId		= 0; 
+    pDesc->wReserved		= 0;
+    pDesc->ulDeviceNum		= This->wDevID;
+    pDesc->dwHeapType		= DSDHEAP_NOHEAP;
+    pDesc->pvDirectDrawHeap	= NULL;
+    pDesc->dwMemStartAddress	= 0;
+    pDesc->dwMemEndAddress	= 0;
+    pDesc->dwMemAllocExtra	= 0;
+    pDesc->pvReserved1		= NULL;
+    pDesc->pvReserved2		= NULL;
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_Open(PIDSDRIVER iface)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    TRACE("(%p)\n",iface);
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_Close(PIDSDRIVER iface)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    TRACE("(%p)\n",iface);
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_GetCaps(PIDSDRIVER iface, PDSDRIVERCAPS pCaps)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    TRACE("(%p,%p)\n",iface,pCaps);
+    memset(pCaps, 0, sizeof(*pCaps));
+
+    pCaps->dwFlags = DSCAPS_PRIMARYMONO;
+    if ( WOutDev[This->wDevID].caps.wChannels == 2 )
+        pCaps->dwFlags |= DSCAPS_PRIMARYSTEREO;
+
+    if ( WOutDev[This->wDevID].caps.dwFormats & (WAVE_FORMAT_1S08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_4S08 ) )
+	pCaps->dwFlags |= DSCAPS_PRIMARY8BIT;
+    
+    if ( WOutDev[This->wDevID].caps.dwFormats & (WAVE_FORMAT_1S16 | WAVE_FORMAT_2S16 | WAVE_FORMAT_4S16))
+	pCaps->dwFlags |= DSCAPS_PRIMARY16BIT;
+
+    pCaps->dwPrimaryBuffers = 1;
+    TRACE("caps=0x%X\n",(unsigned int)pCaps->dwFlags);
+
+    /* the other fields only apply to secondary buffers, which we don't support
+     * (unless we want to mess with wavetable synthesizers and MIDI) */
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_CreateSoundBuffer(PIDSDRIVER iface,
+						      LPWAVEFORMATEX pwfx,
+						      DWORD dwFlags, DWORD dwCardAddress,
+						      LPDWORD pdwcbBufferSize,
+						      LPBYTE *ppbBuffer,
+						      LPVOID *ppvObj)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    IDsDriverBufferImpl** ippdsdb = (IDsDriverBufferImpl**)ppvObj;
+    int err;
+
+    TRACE("(%p,%p,%lx,%lx)\n",iface,pwfx,dwFlags,dwCardAddress);
+    /* we only support primary buffers */
+    if (!(dwFlags & DSBCAPS_PRIMARYBUFFER))
+	return DSERR_UNSUPPORTED;
+    if (This->primary)
+	return DSERR_ALLOCATED;
+    if (dwFlags & (DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN))
+	return DSERR_CONTROLUNAVAIL;
+
+    *ippdsdb = (IDsDriverBufferImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverBufferImpl));
+    if (*ippdsdb == NULL)
+	return DSERR_OUTOFMEMORY;
+    ICOM_VTBL(*ippdsdb) = &dsdbvt;
+    (*ippdsdb)->ref	= 1;
+    (*ippdsdb)->drv	= This;
+
+    err = DSDB_CreateMMAP((*ippdsdb));
+    if ( err != DS_OK )
+     {
+	HeapFree(GetProcessHeap(), 0, *ippdsdb);
+	*ippdsdb = NULL;
+	return err;
+     }
+    *ppbBuffer = (*ippdsdb)->mmap_buffer;
+    *pdwcbBufferSize = (*ippdsdb)->mmap_buflen_bytes;
+
+    This->primary = *ippdsdb;
+
+    /* buffer is ready to go */
+    TRACE("buffer created at %p\n", *ippdsdb);
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_DuplicateSoundBuffer(PIDSDRIVER iface,
+							 PIDSDRIVERBUFFER pBuffer,
+							 LPVOID *ppvObj)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    TRACE("(%p,%p): stub\n",iface,pBuffer);
+    return DSERR_INVALIDCALL;
+}
+
+static ICOM_VTABLE(IDsDriver) dsdvt =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    IDsDriverImpl_QueryInterface,
+    IDsDriverImpl_AddRef,
+    IDsDriverImpl_Release,
+    IDsDriverImpl_GetDriverDesc,
+    IDsDriverImpl_Open,
+    IDsDriverImpl_Close,
+    IDsDriverImpl_GetCaps,
+    IDsDriverImpl_CreateSoundBuffer,
+    IDsDriverImpl_DuplicateSoundBuffer
+};
+
+static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
+{
+    IDsDriverImpl** idrv = (IDsDriverImpl**)drv;
+
+    TRACE("driver created\n");
+
+    /* the HAL isn't much better than the HEL if we can't do mmap() */
+    if (!(WOutDev[wDevID].caps.dwSupport & WAVECAPS_DIRECTSOUND)) {
+	ERR("DirectSound flag not set\n");
+	MESSAGE("This sound card's driver does not support direct access\n");
+	MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
+	return MMSYSERR_NOTSUPPORTED;
+    }
+
+    *idrv = (IDsDriverImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverImpl));
+    if (!*idrv)
+	return MMSYSERR_NOMEM;
+    ICOM_VTBL(*idrv)	= &dsdvt;
+    (*idrv)->ref	= 1;
+
+    (*idrv)->wDevID	= wDevID;
+    (*idrv)->primary	= NULL;
+    return MMSYSERR_NOERROR;
+}
+
+#else /* !HAVE_ALSA */
+
+/**************************************************************************
+ * 				wodMessage (WINEALSA.7)
+ */
+DWORD WINAPI ALSA_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser, 
+                             DWORD dwParam1, DWORD dwParam2)
+{
+    FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
+    return MMSYSERR_NOTENABLED;
+}
+
+#endif /* HAVE_ALSA */
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/winmm/winealsa/audio_05.c	Tue Jun  4 22:31:39 2002
@@ -0,0 +1,1748 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+/*				   
+ * Sample Wine Driver for Advanced Linux Sound System (ALSA)
+ *      Based on version 0.5 of the ALSA API
+ *
+ * Copyright    2002 Eric Pouech
+ *              2002 David Hammerton
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#ifdef HAVE_SYS_MMAN_H
+# include <sys/mman.h>
+#endif
+#include "winbase.h"
+#include "windef.h"
+#include "wingdi.h"
+#include "winerror.h"
+#include "winuser.h"
+#include "mmddk.h"
+#include "dsound.h"
+#include "dsdriver.h"
+#include "alsa.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wave);
+
+
+#if defined(HAVE_ALSA) && (SND_LIB_MAJOR == 0) && (SND_LIB_MINOR == 5)
+
+#define MAX_WAVEOUTDRV 	(1)
+#define MAX_WAVEINDRV 	(1)
+
+/* state diagram for waveOut writing:
+ *
+ * +---------+-------------+---------------+---------------------------------+
+ * |  state  |  function   |     event     |            new state	     |
+ * +---------+-------------+---------------+---------------------------------+
+ * |	     | open()	   |		   | STOPPED		       	     |
+ * | PAUSED  | write()	   | 		   | PAUSED		       	     |
+ * | STOPPED | write()	   | <thrd create> | PLAYING		  	     |
+ * | PLAYING | write()	   | HEADER        | PLAYING		  	     |
+ * | (other) | write()	   | <error>       |		       		     |
+ * | (any)   | pause()	   | PAUSING	   | PAUSED		       	     |
+ * | PAUSED  | restart()   | RESTARTING    | PLAYING (if no thrd => STOPPED) |
+ * | (any)   | reset()	   | RESETTING     | STOPPED		      	     |
+ * | (any)   | close()	   | CLOSING	   | CLOSED		      	     |
+ * +---------+-------------+---------------+---------------------------------+
+ */
+
+/* states of the playing device */
+#define	WINE_WS_PLAYING		0
+#define	WINE_WS_PAUSED		1
+#define	WINE_WS_STOPPED		2
+#define WINE_WS_CLOSED		3
+
+/* events to be send to device */
+enum win_wm_message {
+    WINE_WM_PAUSING = WM_USER + 1, WINE_WM_RESTARTING, WINE_WM_RESETTING, WINE_WM_HEADER,
+    WINE_WM_UPDATE, WINE_WM_BREAKLOOP, WINE_WM_CLOSING
+};
+
+typedef struct {
+    enum win_wm_message 	msg;	/* message identifier */
+    DWORD	                param;  /* parameter for this message */
+    HANDLE	                hEvent;	/* if message is synchronous, handle of event for synchro */
+} ALSA_MSG;
+
+/* implement an in-process message ring for better performance 
+ * (compared to passing thru the server)
+ * this ring will be used by the input (resp output) record (resp playback) routine
+ */
+typedef struct {
+    /* FIXME: this could be made a dynamically growing array (if needed) */
+#define ALSA_RING_BUFFER_SIZE	30
+    ALSA_MSG			messages[ALSA_RING_BUFFER_SIZE];
+    int				msg_tosave;
+    int				msg_toget;
+    HANDLE			msg_event;
+    CRITICAL_SECTION		msg_crst;
+} ALSA_MSG_RING;
+
+typedef struct {
+    /* Windows information */
+    volatile int		state;			/* one of the WINE_WS_ manifest constants */
+    WAVEOPENDESC		waveDesc;
+    WORD			wFlags;
+    PCMWAVEFORMAT		format;
+    WAVEOUTCAPSA		caps;
+
+    /* ALSA information */
+    snd_pcm_t*                  handle;                 /* handle to ALSA device */
+    DWORD			dwFragmentSize;		/* size of ALSA buffer fragment */
+    DWORD                       dwBufferSize;           /* size of whole ALSA buffer in bytes */
+    LPWAVEHDR			lpQueuePtr;		/* start of queued WAVEHDRs (waiting to be notified) */
+    LPWAVEHDR			lpPlayPtr;		/* start of not yet fully played buffers */
+    DWORD			dwPartialOffset;	/* Offset of not yet written bytes in lpPlayPtr */
+
+    LPWAVEHDR			lpLoopPtr;              /* pointer of first buffer in loop, if any */
+    DWORD			dwLoops;		/* private copy of loop counter */
+    
+    DWORD			dwPlayedTotal;		/* number of bytes actually played since opening */
+    DWORD                       dwWrittenTotal;         /* number of bytes written to ALSA buffer since opening */
+
+    /* synchronization stuff */
+    HANDLE			hStartUpEvent;
+    HANDLE			hThread;
+    DWORD			dwThreadID;
+    ALSA_MSG_RING		msgRing;
+
+    /* DirectSound stuff */
+    void*                       mmap_buffer;
+    snd_pcm_mmap_control_t*     mmap_control;
+    unsigned                    mmap_block_size;
+    unsigned                    mmap_block_number;
+} WINE_WAVEOUT;
+
+static WINE_WAVEOUT	WOutDev   [MAX_WAVEOUTDRV];
+static DWORD            ALSA_WodNumDevs;
+
+static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv);
+ 
+/* These strings used only for tracing */
+static const char *wodPlayerCmdString[] = {
+    "WINE_WM_PAUSING",
+    "WINE_WM_RESTARTING",
+    "WINE_WM_RESETTING",
+    "WINE_WM_HEADER",
+    "WINE_WM_UPDATE",
+    "WINE_WM_BREAKLOOP",
+    "WINE_WM_CLOSING",
+};
+
+/*======================================================================*
+ *                  Low level WAVE implementation			*
+ *======================================================================*/
+
+/******************************************************************
+ *		ALSA_WaveInit
+ *
+ * Initialize internal structures from ALSA information
+ */
+LONG ALSA_WaveInit(void)
+{
+    snd_pcm_t*                  h;
+    snd_pcm_info_t              info;
+    snd_pcm_channel_info_t      chn_info;
+
+    TRACE("There are %d cards\n", snd_cards());
+
+    ALSA_WodNumDevs = 0; 
+    if (snd_pcm_open(&h, 0, 0, SND_PCM_OPEN_DUPLEX|SND_PCM_OPEN_NONBLOCK))
+    {
+        ERR("Error open: %s\n", snd_strerror(errno));
+        return -1;
+    }
+    if (snd_pcm_info(h, &info))
+    {
+        ERR("Error info: %s\n", snd_strerror(errno));
+        return -1;
+    }
+    ALSA_WodNumDevs++; 
+    TRACE("type=%u, flags=%s%s%s name=%s #pb=%d cp=%d\n",
+          info.type, (info.flags & SND_PCM_INFO_PLAYBACK) ? "playback " : "", 
+          (info.flags & SND_PCM_INFO_PLAYBACK) ? "capture " : "", 
+          (info.flags & SND_PCM_INFO_DUPLEX) ? "duplex " : "", 
+          info.name, info.playback, info.capture);
+    memset(&chn_info, 0, sizeof(chn_info));
+    if (snd_pcm_channel_info(h, &chn_info))
+    {
+        ERR("Error chn info: %s\n", snd_strerror(errno));
+        return -1;
+    }
+#define X(f,s) ((chn_info.flags & (f)) ? #s " " : "")
+#define Y(f,s) ((chn_info.rates & (f)) ? #s " " : "")
+    TRACE("subdevice=%d name=%s chn=%d mode=%d\n"
+          "\tflags=%s%s%s%s%s%s%s%s%s%s%s\n"
+          "\tfmts=%u rates=%s%s%s%s%s%s%s%s%s%s%s%s%s\n"
+          "\trates=[%d,%d] voices=[%d,%d] buf_size=%d fg_size=[%d,%d] fg_align=%u\n",
+          chn_info.subdevice, chn_info.subname, chn_info.channel, 
+          chn_info.mode, 
+          X(SND_PCM_CHNINFO_MMAP,MMAP),
+          X(SND_PCM_CHNINFO_STREAM,STREAM),
+          X(SND_PCM_CHNINFO_BLOCK,BLOCK),
+          X(SND_PCM_CHNINFO_BATCH,BATCH),
+          X(SND_PCM_CHNINFO_INTERLEAVE,INTERLEAVE),
+          X(SND_PCM_CHNINFO_NONINTERLEAVE,NONINTERLEAVE),
+          X(SND_PCM_CHNINFO_BLOCK_TRANSFER,BLOCK_TRANSFER),
+          X(SND_PCM_CHNINFO_OVERRANGE,OVERRANGE),
+          X(SND_PCM_CHNINFO_MMAP_VALID,MMAP_VALID),
+          X(SND_PCM_CHNINFO_PAUSE,PAUSE),
+          X(SND_PCM_CHNINFO_GLOBAL_PARAMS,GLOBAL_PARAMS),
+          chn_info.formats, 
+          Y(SND_PCM_RATE_CONTINUOUS,CONTINUOUS),
+          Y(SND_PCM_RATE_KNOT,KNOT),
+          Y(SND_PCM_RATE_8000,8000),
+          Y(SND_PCM_RATE_11025,11025),
+          Y(SND_PCM_RATE_16000,16000),
+          Y(SND_PCM_RATE_22050,22050),
+          Y(SND_PCM_RATE_32000,32000),
+          Y(SND_PCM_RATE_44100,44100),
+          Y(SND_PCM_RATE_48000,48000),
+          Y(SND_PCM_RATE_88200,88200),
+          Y(SND_PCM_RATE_96000,96000),
+          Y(SND_PCM_RATE_176400,176400),
+          Y(SND_PCM_RATE_192000,192000),
+          chn_info.min_rate, chn_info.max_rate, 
+          chn_info.min_voices, chn_info.max_voices, 
+          chn_info.buffer_size, 
+          chn_info.min_fragment_size, chn_info.max_fragment_size, 
+          chn_info.fragment_align);
+#undef X
+#undef Y
+    
+    /* FIXME: use better values */
+    WOutDev[0].caps.wMid = 0x0002;
+    WOutDev[0].caps.wPid = 0x0104;
+    strcpy(WOutDev[0].caps.szPname, "SB16 Wave Out");
+    WOutDev[0].caps.vDriverVersion = 0x0100;
+    WOutDev[0].caps.dwFormats = 0x00000000;
+    WOutDev[0].caps.dwSupport = WAVECAPS_VOLUME;
+#define X(r,v) \
+    if (chn_info.rates & SND_PCM_RATE_##r) \
+    { \
+        if (chn_info.formats & SND_PCM_FMT_U8) \
+        { \
+            if (chn_info.min_voices <= 1 && 1 <= chn_info.max_voices) \
+                WOutDev[0].caps.dwFormats |= WAVE_FORMAT_##v##S08; \
+            if (chn_info.min_voices <= 2 && 2 <= chn_info.max_voices) \
+                WOutDev[0].caps.dwFormats |= WAVE_FORMAT_##v##S08; \
+        } \
+        if (chn_info.formats & SND_PCM_FMT_S16_LE) \
+        { \
+            if (chn_info.min_voices <= 1 && 1 <= chn_info.max_voices) \
+                WOutDev[0].caps.dwFormats |= WAVE_FORMAT_##v##S16; \
+            if (chn_info.min_voices <= 2 && 2 <= chn_info.max_voices) \
+                WOutDev[0].caps.dwFormats |= WAVE_FORMAT_##v##S16; \
+        } \
+    }
+    X(11025,1);
+    X(22050,2);
+    X(44100,4);
+#undef X
+    if (chn_info.min_voices > 1) FIXME("-");
+    WOutDev[0].caps.wChannels = (chn_info.max_voices >= 2) ? 2 : 1;
+    if (chn_info.min_voices <= 2 && 2 <= chn_info.max_voices) 
+        WOutDev[0].caps.dwSupport |= WAVECAPS_LRVOLUME;
+
+    /* FIXME: always true ? */
+    WOutDev[0].caps.dwSupport |= WAVECAPS_SAMPLEACCURATE;
+
+    /* FIXME: is test sufficient ? */
+    if (chn_info.flags & SND_PCM_CHNINFO_MMAP)
+        WOutDev[0].caps.dwSupport |= WAVECAPS_DIRECTSOUND;
+
+    TRACE("Configured with dwFmts=%08lx dwSupport=%08lx\n", 
+          WOutDev[0].caps.dwFormats, WOutDev[0].caps.dwSupport);
+    
+    snd_pcm_close(h);
+
+    return 0;
+}
+
+/******************************************************************
+ *		ALSA_InitRingMessage
+ *
+ * Initialize the ring of messages for passing between driver's caller and playback/record
+ * thread
+ */
+static int ALSA_InitRingMessage(ALSA_MSG_RING* omr)
+{
+    omr->msg_toget = 0;
+    omr->msg_tosave = 0;
+    omr->msg_event = CreateEventA(NULL, FALSE, FALSE, NULL);
+    memset(omr->messages, 0, sizeof(ALSA_MSG) * ALSA_RING_BUFFER_SIZE);
+    InitializeCriticalSection(&omr->msg_crst);
+    return 0;
+}
+
+/******************************************************************
+ *		ALSA_DestroyRingMessage
+ *
+ */
+static int ALSA_DestroyRingMessage(ALSA_MSG_RING* omr)
+{
+    CloseHandle(omr->msg_event);
+    DeleteCriticalSection(&omr->msg_crst);
+    return 0;
+}
+
+/******************************************************************
+ *		ALSA_AddRingMessage
+ *
+ * Inserts a new message into the ring (should be called from DriverProc derivated routines)
+ */
+static int ALSA_AddRingMessage(ALSA_MSG_RING* omr, enum win_wm_message msg, DWORD param, BOOL wait)
+{
+    HANDLE	hEvent = INVALID_HANDLE_VALUE;
+
+    EnterCriticalSection(&omr->msg_crst);
+    if ((omr->msg_toget == ((omr->msg_tosave + 1) % ALSA_RING_BUFFER_SIZE))) /* buffer overflow ? */
+    {
+	ERR("buffer overflow !?\n");
+        LeaveCriticalSection(&omr->msg_crst);
+	return 0;
+    }
+    if (wait)
+    {
+        hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+        if (hEvent == INVALID_HANDLE_VALUE)
+        {
+            ERR("can't create event !?\n");
+            LeaveCriticalSection(&omr->msg_crst);
+            return 0;
+        }
+        if (omr->msg_toget != omr->msg_tosave && omr->messages[omr->msg_toget].msg != WINE_WM_HEADER)
+            FIXME("two fast messages in the queue!!!!\n");
+
+        /* fast messages have to be added at the start of the queue */
+        omr->msg_toget = (omr->msg_toget + ALSA_RING_BUFFER_SIZE - 1) % ALSA_RING_BUFFER_SIZE;
+
+        omr->messages[omr->msg_toget].msg = msg;
+        omr->messages[omr->msg_toget].param = param;
+        omr->messages[omr->msg_toget].hEvent = hEvent;
+    }
+    else
+    { 
+        omr->messages[omr->msg_tosave].msg = msg;
+        omr->messages[omr->msg_tosave].param = param;
+        omr->messages[omr->msg_tosave].hEvent = INVALID_HANDLE_VALUE;
+        omr->msg_tosave = (omr->msg_tosave + 1) % ALSA_RING_BUFFER_SIZE;
+    }
+    LeaveCriticalSection(&omr->msg_crst);
+    /* signal a new message */
+    SetEvent(omr->msg_event);
+    if (wait)
+    {
+        /* wait for playback/record thread to have processed the message */
+        WaitForSingleObject(hEvent, INFINITE);
+        CloseHandle(hEvent);
+    }
+    return 1;
+}
+
+/******************************************************************
+ *		ALSA_RetrieveRingMessage
+ *
+ * Get a message from the ring. Should be called by the playback/record thread.
+ */
+static int ALSA_RetrieveRingMessage(ALSA_MSG_RING* omr, 
+                                   enum win_wm_message *msg, DWORD *param, HANDLE *hEvent)
+{
+    EnterCriticalSection(&omr->msg_crst);
+
+    if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
+    {
+        LeaveCriticalSection(&omr->msg_crst);
+	return 0;
+    }
+	
+    *msg = omr->messages[omr->msg_toget].msg;
+    omr->messages[omr->msg_toget].msg = 0;
+    *param = omr->messages[omr->msg_toget].param;
+    *hEvent = omr->messages[omr->msg_toget].hEvent;
+    omr->msg_toget = (omr->msg_toget + 1) % ALSA_RING_BUFFER_SIZE;
+    LeaveCriticalSection(&omr->msg_crst);
+    return 1;
+}
+
+/*======================================================================*
+ *                  Low level WAVE OUT implementation			*
+ *======================================================================*/
+
+/**************************************************************************
+ * 			wodNotifyClient			[internal]
+ */
+static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
+{
+    TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
+    
+    switch (wMsg) {
+    case WOM_OPEN:
+    case WOM_CLOSE:
+    case WOM_DONE:
+	if (wwo->wFlags != DCB_NULL && 
+	    !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, wwo->waveDesc.hWave, 
+			    wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
+	    WARN("can't notify client !\n");
+	    return MMSYSERR_ERROR;
+	}
+	break;
+    default:
+	FIXME("Unknown callback message %u\n", wMsg);
+        return MMSYSERR_INVALPARAM;
+    }
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodUpdatePlayedTotal	[internal]
+ *
+ */
+static BOOL wodUpdatePlayedTotal(WINE_WAVEOUT* wwo, snd_pcm_channel_status_t* ps)
+{
+    snd_pcm_channel_status_t    s;
+    snd_pcm_channel_status_t*   status = (ps) ? ps : &s;
+    
+    if (snd_pcm_channel_status(wwo->handle, status))
+    {
+        ERR("Can't get channel status: %s\n", snd_strerror(errno));
+        return FALSE;
+    }
+    wwo->dwPlayedTotal = wwo->dwWrittenTotal - (wwo->dwBufferSize - status->count);
+    if (wwo->dwPlayedTotal != status->scount)
+    {
+        FIXME("Ooch: %u played by ALSA, %lu counted by driver\n", 
+              status->scount, wwo->dwPlayedTotal);
+        if (wwo->dwPlayedTotal & 0x8000000) wwo->dwPlayedTotal = 0;
+    }
+    return TRUE;
+}
+
+/**************************************************************************
+ * 				wodPlayer_BeginWaveHdr          [internal]
+ *
+ * Makes the specified lpWaveHdr the currently playing wave header.
+ * If the specified wave header is a begin loop and we're not already in
+ * a loop, setup the loop.
+ */
+static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
+{
+    wwo->lpPlayPtr = lpWaveHdr;
+
+    if (!lpWaveHdr) return;
+
+    if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
+	if (wwo->lpLoopPtr) {
+	    WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
+	} else {
+	    TRACE("Starting loop (%ldx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
+	    wwo->lpLoopPtr = lpWaveHdr;
+	    /* Windows does not touch WAVEHDR.dwLoops,
+	     * so we need to make an internal copy */
+	    wwo->dwLoops = lpWaveHdr->dwLoops;
+	}
+    }
+    wwo->dwPartialOffset = 0;
+}
+
+/**************************************************************************
+ * 				wodPlayer_PlayPtrNext	        [internal]
+ *
+ * Advance the play pointer to the next waveheader, looping if required.
+ */
+static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEOUT* wwo)
+{
+    LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
+
+    wwo->dwPartialOffset = 0;
+    if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
+	/* We're at the end of a loop, loop if required */
+	if (--wwo->dwLoops > 0) {
+	    wwo->lpPlayPtr = wwo->lpLoopPtr;
+	} else {
+	    /* Handle overlapping loops correctly */
+	    if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
+		FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
+		/* shall we consider the END flag for the closing loop or for
+		 * the opening one or for both ???
+		 * code assumes for closing loop only
+		 */
+	    } else {
+                lpWaveHdr = lpWaveHdr->lpNext;
+            }
+            wwo->lpLoopPtr = NULL;
+            wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
+	}
+    } else {
+	/* We're not in a loop.  Advance to the next wave header */
+	wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
+    }
+
+    return lpWaveHdr;
+}
+
+/**************************************************************************
+ * 			     wodPlayer_DSPWait			[internal]
+ * Returns the number of milliseconds to wait for the DSP buffer to write 
+ * one fragment.
+ */
+static DWORD wodPlayer_DSPWait(const WINE_WAVEOUT *wwo)
+{
+    /* time for one fragment to be played */
+    return wwo->dwFragmentSize * 1000 / wwo->format.wf.nAvgBytesPerSec;
+}
+
+/**************************************************************************
+ * 			     wodPlayer_NotifyWait               [internal]
+ * Returns the number of milliseconds to wait before attempting to notify
+ * completion of the specified wavehdr.
+ * This is based on the number of bytes remaining to be written in the
+ * wave.
+ */
+static DWORD wodPlayer_NotifyWait(const WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
+{
+    DWORD dwMillis;
+
+    if (lpWaveHdr->reserved < wwo->dwPlayedTotal) {
+	dwMillis = 1;
+    } else {
+	dwMillis = (lpWaveHdr->reserved - wwo->dwPlayedTotal) * 1000 / wwo->format.wf.nAvgBytesPerSec;
+	if (!dwMillis) dwMillis = 1;
+    }
+
+    return dwMillis;
+}
+
+
+/**************************************************************************
+ * 			     wodPlayer_WriteMaxFrags            [internal]
+ * Writes the maximum number of bytes palsaible to the DSP and returns
+ * the number of bytes written.
+ */
+static int wodPlayer_WriteMaxFrags(WINE_WAVEOUT* wwo, DWORD* bytes)
+{
+    /* Only attempt to write to free bytes */
+    DWORD dwLength = wwo->lpPlayPtr->dwBufferLength - wwo->dwPartialOffset;
+    int toWrite = min(dwLength, *bytes);
+    int written;
+
+    TRACE("Writing wavehdr %p.%lu[%lu]\n", 
+          wwo->lpPlayPtr, wwo->dwPartialOffset, wwo->lpPlayPtr->dwBufferLength);
+    written = snd_pcm_write(wwo->handle, wwo->lpPlayPtr->lpData + wwo->dwPartialOffset, toWrite);
+    if (written <= 0) 
+    {
+        ERR("Wrote: %d bytes (%s)\n", written, snd_strerror(errno));
+        return written;
+    }
+
+    if (written >= dwLength) {
+        /* If we wrote all current wavehdr, skip to the next one */
+        wodPlayer_PlayPtrNext(wwo);
+    } else {
+        /* Remove the amount written */
+        wwo->dwPartialOffset += written;
+    }
+    *bytes -= written;
+    wwo->dwWrittenTotal += written;
+
+    return written;
+}
+
+
+/**************************************************************************
+ * 				wodPlayer_NotifyCompletions	[internal]
+ *
+ * Notifies and remove from queue all wavehdrs which have been played to
+ * the speaker (ie. they have cleared the ALSA buffer).  If force is true,
+ * we notify all wavehdrs and remove them all from the queue even if they
+ * are unplayed or part of a loop.
+ */
+static DWORD wodPlayer_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
+{
+    LPWAVEHDR		lpWaveHdr;
+
+    /* Start from lpQueuePtr and keep notifying until:
+     * - we hit an unwritten wavehdr
+     * - we hit the beginning of a running loop
+     * - we hit a wavehdr which hasn't finished playing
+     */
+    while ((lpWaveHdr = wwo->lpQueuePtr) && 
+           (force || 
+            (lpWaveHdr != wwo->lpPlayPtr &&
+             lpWaveHdr != wwo->lpLoopPtr &&
+             lpWaveHdr->reserved <= wwo->dwPlayedTotal))) {
+
+	wwo->lpQueuePtr = lpWaveHdr->lpNext;
+
+	lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
+	lpWaveHdr->dwFlags |= WHDR_DONE;
+
+	wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
+    }
+    return  (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != wwo->lpLoopPtr) ? 
+        wodPlayer_NotifyWait(wwo, lpWaveHdr) : INFINITE;
+}
+
+/**************************************************************************
+ * 				wodPlayer_Reset			[internal]
+ *
+ * wodPlayer helper. Resets current output stream.
+ */
+static	void	wodPlayer_Reset(WINE_WAVEOUT* wwo, BOOL reset)
+{
+    wodUpdatePlayedTotal(wwo, NULL);
+    /* updates current notify list */
+    wodPlayer_NotifyCompletions(wwo, FALSE);
+
+    if (snd_pcm_playback_flush(wwo->handle) != 0) {
+	FIXME("flush: %s\n", snd_strerror(errno));
+	wwo->hThread = 0;
+	wwo->state = WINE_WS_STOPPED;
+	ExitThread(-1);
+    }
+
+    if (reset) {
+        enum win_wm_message	msg;
+        DWORD		        param;
+        HANDLE		        ev;
+
+	/* remove any buffer */
+	wodPlayer_NotifyCompletions(wwo, TRUE);
+
+	wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
+	wwo->state = WINE_WS_STOPPED;
+	wwo->dwPlayedTotal = wwo->dwWrittenTotal = 0;
+        /* Clear partial wavehdr */
+        wwo->dwPartialOffset = 0;
+
+        /* remove any existing message in the ring */
+        EnterCriticalSection(&wwo->msgRing.msg_crst);
+        /* return all pending headers in queue */
+        while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev))
+        {
+            if (msg != WINE_WM_HEADER) 
+            {
+                FIXME("shouldn't have headers left\n");
+                SetEvent(ev);
+                continue;
+            }
+            ((LPWAVEHDR)param)->dwFlags &= ~WHDR_INQUEUE;
+            ((LPWAVEHDR)param)->dwFlags |= WHDR_DONE;
+
+            wodNotifyClient(wwo, WOM_DONE, param, 0);
+        }
+        ResetEvent(wwo->msgRing.msg_event);
+        LeaveCriticalSection(&wwo->msgRing.msg_crst);
+    } else {
+        if (wwo->lpLoopPtr) {
+            /* complicated case, not handled yet (could imply modifying the loop counter */
+            FIXME("Pausing while in loop isn't correctly handled yet, except strange results\n");
+            wwo->lpPlayPtr = wwo->lpLoopPtr;
+            wwo->dwPartialOffset = 0;
+            wwo->dwWrittenTotal = wwo->dwPlayedTotal; /* this is wrong !!! */
+        } else {
+            LPWAVEHDR   ptr;
+            DWORD       sz = wwo->dwPartialOffset;
+
+            /* reset all the data as if we had written only up to lpPlayedTotal bytes */
+            /* compute the max size playable from lpQueuePtr */
+            for (ptr = wwo->lpQueuePtr; ptr != wwo->lpPlayPtr; ptr = ptr->lpNext) {
+                sz += ptr->dwBufferLength;
+            }
+            /* because the reset lpPlayPtr will be lpQueuePtr */
+            if (wwo->dwWrittenTotal > wwo->dwPlayedTotal + sz) ERR("grin\n");
+            wwo->dwPartialOffset = sz - (wwo->dwWrittenTotal - wwo->dwPlayedTotal);
+            wwo->dwWrittenTotal = wwo->dwPlayedTotal;
+            wwo->lpPlayPtr = wwo->lpQueuePtr;
+        }
+	wwo->state = WINE_WS_PAUSED;
+    }
+}
+
+/**************************************************************************
+ * 		      wodPlayer_ProcessMessages			[internal]
+ */
+static void wodPlayer_ProcessMessages(WINE_WAVEOUT* wwo)
+{
+    LPWAVEHDR           lpWaveHdr;
+    enum win_wm_message	msg;
+    DWORD		param;
+    HANDLE		ev;
+
+    while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev)) {
+//        TRACE("Received %s %lx\n", wodPlayerCmdString[msg - WM_USER - 1], param);
+
+	switch (msg) {
+	case WINE_WM_PAUSING:
+	    wodPlayer_Reset(wwo, FALSE);
+	    SetEvent(ev);
+	    break;
+	case WINE_WM_RESTARTING:
+            if (wwo->state == WINE_WS_PAUSED)
+            {
+                snd_pcm_playback_prepare(wwo->handle);
+                wwo->state = WINE_WS_PLAYING;
+            } 
+	    SetEvent(ev);
+	    break;
+	case WINE_WM_HEADER:
+	    lpWaveHdr = (LPWAVEHDR)param;
+	    
+	    /* insert buffer at the end of queue */
+	    {
+		LPWAVEHDR*	wh;
+		for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
+		*wh = lpWaveHdr;
+	    }
+            if (!wwo->lpPlayPtr)
+                wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
+	    if (wwo->state == WINE_WS_STOPPED)
+		wwo->state = WINE_WS_PLAYING;
+	    break;
+	case WINE_WM_RESETTING:
+	    wodPlayer_Reset(wwo, TRUE);
+	    SetEvent(ev);
+	    break;
+        case WINE_WM_UPDATE:
+            wodUpdatePlayedTotal(wwo, NULL);
+	    SetEvent(ev);
+            break;
+        case WINE_WM_BREAKLOOP:
+            if (wwo->state == WINE_WS_PLAYING && wwo->lpLoopPtr != NULL) {
+                /* ensure exit at end of current loop */
+                wwo->dwLoops = 1;
+            }
+	    SetEvent(ev);
+            break;
+	case WINE_WM_CLOSING:
+	    /* sanity check: this should not happen since the device must have been reset before */
+	    if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
+	    wwo->hThread = 0;
+	    wwo->state = WINE_WS_CLOSED;
+	    SetEvent(ev);
+	    ExitThread(0);
+	    /* shouldn't go here */
+	default:
+	    FIXME("unknown message %d\n", msg);
+	    break;
+	}
+    }
+}
+
+/**************************************************************************
+ * 			     wodPlayer_FeedDSP			[internal]
+ * Feed as much sound data as we can into the DSP and return the number of
+ * milliseconds before it will be necessary to feed the DSP again.
+ */
+static DWORD wodPlayer_FeedDSP(WINE_WAVEOUT* wwo)
+{
+    snd_pcm_channel_status_t    status;
+    DWORD                       availInQ;
+
+    wodUpdatePlayedTotal(wwo, &status);
+    availInQ = status.free;
+
+#if 0
+    TODO;
+    TRACE("fragments=%d/%d, fragsize=%d, bytes=%d\n",
+          dspspace.fragments, dspspace.fragstotal, dspspace.fragsize, dspspace.bytes);
+#endif
+
+    /* input queue empty and output buffer with less than one fragment to play */
+    /* FIXME: we should be able to catch OVERRUN errors */
+    if (!wwo->lpPlayPtr && wwo->dwBufferSize < availInQ + 2 * wwo->dwFragmentSize) {
+        TRACE("Run out of wavehdr:s... flushing\n");
+        snd_pcm_playback_drain(wwo->handle);
+        wwo->dwPlayedTotal = wwo->dwWrittenTotal;
+        return INFINITE;
+    }
+
+    /* no more room... no need to try to feed */
+    if (status.free > 0) {
+        /* Feed from partial wavehdr */
+        if (wwo->lpPlayPtr && wwo->dwPartialOffset != 0) {
+            wodPlayer_WriteMaxFrags(wwo, &availInQ);
+        }
+
+        /* Feed wavehdrs until we run out of wavehdrs or DSP space */
+        if (wwo->dwPartialOffset == 0) {
+            while (wwo->lpPlayPtr && availInQ > 0) {
+                /* note the value that dwPlayedTotal will return when this wave finishes playing */
+                wwo->lpPlayPtr->reserved = wwo->dwWrittenTotal + wwo->lpPlayPtr->dwBufferLength;
+                wodPlayer_WriteMaxFrags(wwo, &availInQ);
+            }
+        }
+    }
+    return wodPlayer_DSPWait(wwo);
+}
+
+
+/**************************************************************************
+ * 				wodPlayer			[internal]
+ */
+static	DWORD	CALLBACK	wodPlayer(LPVOID pmt)
+{
+    WORD	  uDevID = (DWORD)pmt;
+    WINE_WAVEOUT* wwo = (WINE_WAVEOUT*)&WOutDev[uDevID];
+    DWORD         dwNextFeedTime = INFINITE;   /* Time before DSP needs feeding */
+    DWORD         dwNextNotifyTime = INFINITE; /* Time before next wave completion */
+    DWORD         dwSleepTime;
+
+    wwo->state = WINE_WS_STOPPED;
+    SetEvent(wwo->hStartUpEvent);
+
+    for (;;) {
+        /** Wait for the shortest time before an action is required.  If there
+         *  are no pending actions, wait forever for a command.
+         */
+        dwSleepTime = min(dwNextFeedTime, dwNextNotifyTime);
+        TRACE("waiting %lums (%lu,%lu)\n", dwSleepTime, dwNextFeedTime, dwNextNotifyTime);
+        WaitForSingleObject(wwo->msgRing.msg_event, dwSleepTime);
+	wodPlayer_ProcessMessages(wwo);
+	if (wwo->state == WINE_WS_PLAYING) {
+	    dwNextFeedTime = wodPlayer_FeedDSP(wwo);
+	    dwNextNotifyTime = wodPlayer_NotifyCompletions(wwo, FALSE);
+	} else {
+	    dwNextFeedTime = dwNextNotifyTime = INFINITE;
+	}
+    }
+}
+
+/**************************************************************************
+ * 			wodGetDevCaps				[internal]
+ */
+static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSA lpCaps, DWORD dwSize)
+{
+    TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
+    
+    if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
+    
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	TRACE("MAX_WAVOUTDRV reached !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+
+    memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodOpen				[internal]
+ */
+static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
+{
+    WINE_WAVEOUT*	        wwo; 
+    snd_pcm_channel_params_t    params;
+
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
+    if (lpDesc == NULL) {
+	WARN("Invalid Parameter !\n");
+	return MMSYSERR_INVALPARAM;
+    }
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	TRACE("MAX_WAVOUTDRV reached !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+
+    /* only PCM format is supported so far... */
+    if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
+	lpDesc->lpFormat->nChannels == 0 ||
+	lpDesc->lpFormat->nSamplesPerSec == 0) {
+	WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n", 
+	     lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
+	     lpDesc->lpFormat->nSamplesPerSec);
+	return WAVERR_BADFORMAT;
+    }
+
+    if (dwFlags & WAVE_FORMAT_QUERY) {
+	TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n", 
+	     lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
+	     lpDesc->lpFormat->nSamplesPerSec);
+	return MMSYSERR_NOERROR;
+    }
+
+    wwo = &WOutDev[wDevID];
+
+    if ((dwFlags & WAVE_DIRECTSOUND) && !(wwo->caps.dwSupport & WAVECAPS_DIRECTSOUND))
+	/* not supported, ignore it */
+	dwFlags &= ~WAVE_DIRECTSOUND;
+
+    wwo->handle = 0;
+    if (snd_pcm_open(&wwo->handle, wDevID, 0, SND_PCM_OPEN_DUPLEX|SND_PCM_OPEN_NONBLOCK))
+    {
+        ERR("Error open: %s\n", snd_strerror(errno)); 
+	return MMSYSERR_NOTENABLED;
+    }
+
+    memset(&params, 0, sizeof(params));
+    params.channel = SND_PCM_CHANNEL_PLAYBACK;
+    params.start_mode = SND_PCM_START_DATA;
+    params.stop_mode = SND_PCM_STOP_STOP;
+    params.mode = SND_PCM_MODE_STREAM; 
+    params.buf.stream.queue_size = 0x1000;
+    params.buf.stream.fill = SND_PCM_FILL_SILENCE;
+    params.buf.stream.max_fill = 0x800;
+
+    wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
+    
+    memcpy(&wwo->waveDesc, lpDesc, 	     sizeof(WAVEOPENDESC));
+    memcpy(&wwo->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
+    
+    if (wwo->format.wBitsPerSample == 0) {
+	WARN("Resetting zeroed wBitsPerSample\n");
+	wwo->format.wBitsPerSample = 8 *
+	    (wwo->format.wf.nAvgBytesPerSec /
+	     wwo->format.wf.nSamplesPerSec) /
+	    wwo->format.wf.nChannels;
+    }
+    params.format.interleave = 1;
+    params.format.format = (wwo->format.wBitsPerSample == 16) ? 
+        SND_PCM_SFMT_S16_LE : SND_PCM_SFMT_U8;
+    params.format.rate = wwo->format.wf.nSamplesPerSec;
+    params.format.voices = (wwo->format.wf.nChannels > 1) ? 2 : 1;
+    params.format.special = 0;
+
+    if (snd_pcm_channel_params(wwo->handle, &params))
+    {
+        ERR("Can't set params: %s\n", snd_strerror(errno));
+        snd_pcm_close(wwo->handle);
+        wwo->handle = NULL;
+        return MMSYSERR_INVALPARAM;
+    }
+#if 0
+    TODO;
+    if (params.format.rate != format != ((wwo->format.wBitsPerSample == 16) ? AFMT_S16_LE : AFMT_U8))
+	ERR("Can't set format to %d (%d)\n", 
+	    (wwo->format.wBitsPerSample == 16) ? AFMT_S16_LE : AFMT_U8, format);
+    if (dsp_stereo != (wwo->format.wf.nChannels > 1) ? 1 : 0) 
+	ERR("Can't set stereo to %u (%d)\n", 
+	    (wwo->format.wf.nChannels > 1) ? 1 : 0, dsp_stereo);
+    if (!NEAR_MATCH(sample_rate, wwo->format.wf.nSamplesPerSec))
+	ERR("Can't set sample_rate to %lu (%d)\n", 
+	    wwo->format.wf.nSamplesPerSec, sample_rate);
+#endif
+
+    snd_pcm_playback_prepare(wwo->handle);
+
+    /* Remember fragsize and total buffer size for future use */
+    wwo->dwBufferSize = params.buf.stream.queue_size;
+    /* FIXME: should get rid off fragment size */
+    wwo->dwFragmentSize = wwo->dwBufferSize >> 4; /* why not */
+    wwo->dwPlayedTotal = 0;
+    wwo->dwWrittenTotal = 0;
+    wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
+
+    ALSA_InitRingMessage(&wwo->msgRing);
+
+    if (!(dwFlags & WAVE_DIRECTSOUND)) {
+	wwo->hStartUpEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+	wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD)wDevID, 0, &(wwo->dwThreadID));
+	WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
+	CloseHandle(wwo->hStartUpEvent);
+    } else {
+	wwo->hThread = INVALID_HANDLE_VALUE;
+	wwo->dwThreadID = 0;
+    }
+    wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
+
+    TRACE("handle=%08lx fragmentSize=%ld\n", 
+	  (DWORD)wwo->handle, wwo->dwFragmentSize);
+    if (wwo->dwFragmentSize % wwo->format.wf.nBlockAlign)
+	ERR("Fragment doesn't contain an integral number of data blocks\n");
+
+    TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n", 
+	  wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec, 
+	  wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
+	  wwo->format.wf.nBlockAlign);
+    
+    return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
+}
+
+/**************************************************************************
+ * 				wodClose			[internal]
+ */
+static DWORD wodClose(WORD wDevID)
+{
+    DWORD		ret = MMSYSERR_NOERROR;
+    WINE_WAVEOUT*	wwo;
+
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    wwo = &WOutDev[wDevID];
+    if (wwo->lpQueuePtr) {
+	WARN("buffers still playing !\n");
+	ret = WAVERR_STILLPLAYING;
+    } else {
+	if (wwo->hThread != INVALID_HANDLE_VALUE) {
+	    ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_CLOSING, 0, TRUE);
+	}
+	if (wwo->mmap_buffer) {
+            snd_pcm_munmap(wwo->handle, SND_PCM_CHANNEL_PLAYBACK);
+            wwo->mmap_buffer = wwo->mmap_control = NULL;
+	}
+
+        ALSA_DestroyRingMessage(&wwo->msgRing);
+
+        snd_pcm_close(wwo->handle);
+	wwo->handle = NULL;
+	wwo->dwFragmentSize = 0;
+	ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
+    }
+    return ret;
+}
+
+/**************************************************************************
+ * 				wodWrite			[internal]
+ * 
+ */
+static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
+    
+    /* first, do the sanity checks... */
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].handle == NULL) {
+        WARN("bad dev ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED)) 
+	return WAVERR_UNPREPARED;
+    
+    if (lpWaveHdr->dwFlags & WHDR_INQUEUE) 
+	return WAVERR_STILLPLAYING;
+
+    lpWaveHdr->dwFlags &= ~WHDR_DONE;
+    lpWaveHdr->dwFlags |= WHDR_INQUEUE;
+    lpWaveHdr->lpNext = 0;
+
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
+
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodPrepare			[internal]
+ */
+static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
+    
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
+	return WAVERR_STILLPLAYING;
+    
+    lpWaveHdr->dwFlags |= WHDR_PREPARED;
+    lpWaveHdr->dwFlags &= ~WHDR_DONE;
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodUnprepare			[internal]
+ */
+static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+    TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
+    
+    if (wDevID >= MAX_WAVEOUTDRV) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
+	return WAVERR_STILLPLAYING;
+    
+    lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
+    lpWaveHdr->dwFlags |= WHDR_DONE;
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 			wodPause				[internal]
+ */
+static DWORD wodPause(WORD wDevID)
+{
+    TRACE("(%u);!\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_PAUSING, 0, TRUE);
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 			wodRestart				[internal]
+ */
+static DWORD wodRestart(WORD wDevID)
+{
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (WOutDev[wDevID].state == WINE_WS_PAUSED) {
+	ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESTARTING, 0, TRUE);
+    }
+    
+    /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
+    /* FIXME: Myst crashes with this ... hmm -MM
+       return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
+    */
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 			wodReset				[internal]
+ */
+static DWORD wodReset(WORD wDevID)
+{
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
+    
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodGetPosition			[internal]
+ */
+static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
+{
+    int			time;
+    DWORD		val;
+    WINE_WAVEOUT*	wwo;
+
+    TRACE("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    
+    if (lpTime == NULL)	return MMSYSERR_INVALPARAM;
+
+    wwo = &WOutDev[wDevID];
+    ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_UPDATE, 0, TRUE);
+    val = wwo->dwPlayedTotal;
+
+    TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%lu nChannels=%u nAvgBytesPerSec=%lu\n", 
+	  lpTime->wType, wwo->format.wBitsPerSample, 
+	  wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels, 
+	  wwo->format.wf.nAvgBytesPerSec); 
+    TRACE("dwPlayedTotal=%lu\n", val);
+    
+    switch (lpTime->wType) {
+    case TIME_BYTES:
+	lpTime->u.cb = val;
+	TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
+	break;
+    case TIME_SAMPLES:
+	lpTime->u.sample = val * 8 / wwo->format.wBitsPerSample /wwo->format.wf.nChannels;
+	TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
+	break;
+    case TIME_SMPTE:
+	time = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
+	lpTime->u.smpte.hour = time / 108000;
+	time -= lpTime->u.smpte.hour * 108000;
+	lpTime->u.smpte.min = time / 1800;
+	time -= lpTime->u.smpte.min * 1800;
+	lpTime->u.smpte.sec = time / 30;
+	time -= lpTime->u.smpte.sec * 30;
+	lpTime->u.smpte.frame = time;
+	lpTime->u.smpte.fps = 30;
+	TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
+	      lpTime->u.smpte.hour, lpTime->u.smpte.min,
+	      lpTime->u.smpte.sec, lpTime->u.smpte.frame);
+	break;
+    default:
+	FIXME("Format %d not supported ! use TIME_MS !\n", lpTime->wType);
+	lpTime->wType = TIME_MS;
+    case TIME_MS:
+	lpTime->u.ms = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
+	TRACE("TIME_MS=%lu\n", lpTime->u.ms);
+	break;
+    }
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodBreakLoop			[internal]
+ */
+static DWORD wodBreakLoop(WORD wDevID)
+{
+    TRACE("(%u);\n", wDevID);
+    
+    if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].handle == NULL) {
+	WARN("bad device ID !\n");
+	return MMSYSERR_BADDEVICEID;
+    }
+    ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_BREAKLOOP, 0, TRUE);
+    return MMSYSERR_NOERROR;
+}
+    
+/**************************************************************************
+ * 				wodGetVolume			[internal]
+ */
+static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
+{
+    int 	mixer;
+    int		volume;
+    DWORD	left, right;
+    
+    TRACE("(%u, %p);\n", wDevID, lpdwVol);
+    
+    if (lpdwVol == NULL) 
+	return MMSYSERR_NOTENABLED;
+#if 0
+    TODO;
+    if ((mixer = open(MIXER_DEV, O_RDONLY|O_NDELAY)) < 0) {
+	WARN("mixer device not available !\n");
+	return MMSYSERR_NOTENABLED;
+    }
+    if (ioctl(mixer, SOUND_MIXER_READ_PCM, &volume) == -1) {
+	WARN("unable to read mixer !\n");
+	return MMSYSERR_NOTENABLED;
+    }
+    close(mixer);
+#endif
+    left = LOBYTE(volume);
+    right = HIBYTE(volume);
+    TRACE("left=%ld right=%ld !\n", left, right);
+    *lpdwVol = ((left * 0xFFFFl) / 100) + (((right * 0xFFFFl) / 100) << 16);
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodSetVolume			[internal]
+ */
+static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
+{
+    int 	mixer;
+    int		volume;
+    DWORD	left, right;
+
+    TRACE("(%u, %08lX);\n", wDevID, dwParam);
+
+    left  = (LOWORD(dwParam) * 100) / 0xFFFFl;
+    right = (HIWORD(dwParam) * 100) / 0xFFFFl;
+    volume = left + (right << 8);
+    
+#if 0
+    TODO;
+    if ((mixer = open(MIXER_DEV, O_WRONLY|O_NDELAY)) < 0) {
+	WARN("mixer device not available !\n");
+	return MMSYSERR_NOTENABLED;
+    }
+    if (ioctl(mixer, SOUND_MIXER_WRITE_PCM, &volume) == -1) {
+	WARN("unable to set mixer !\n");
+	return MMSYSERR_NOTENABLED;
+    } else {
+	TRACE("volume=%04x\n", (unsigned)volume);
+    }
+    close(mixer);
+#endif
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodGetNumDevs			[internal]
+ */
+static	DWORD	wodGetNumDevs(void)
+{
+    return ALSA_WodNumDevs;
+}
+
+/**************************************************************************
+ * 				wodMessage (WINEALSA.7)
+ */
+DWORD WINAPI ALSA_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser, 
+                             DWORD dwParam1, DWORD dwParam2)
+{
+    TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
+	  wDevID, wMsg, dwUser, dwParam1, dwParam2);
+    
+    switch (wMsg) {
+    case DRVM_INIT:
+    case DRVM_EXIT:
+    case DRVM_ENABLE:
+    case DRVM_DISABLE:
+	/* FIXME: Pretend this is supported */
+	return 0;
+    case WODM_OPEN:	 	return wodOpen		(wDevID, (LPWAVEOPENDESC)dwParam1,	dwParam2);
+    case WODM_CLOSE:	 	return wodClose		(wDevID);
+    case WODM_WRITE:	 	return wodWrite		(wDevID, (LPWAVEHDR)dwParam1,		dwParam2);
+    case WODM_PAUSE:	 	return wodPause		(wDevID);
+    case WODM_GETPOS:	 	return wodGetPosition	(wDevID, (LPMMTIME)dwParam1, 		dwParam2);
+    case WODM_BREAKLOOP: 	return wodBreakLoop     (wDevID);
+    case WODM_PREPARE:	 	return wodPrepare	(wDevID, (LPWAVEHDR)dwParam1, 		dwParam2);
+    case WODM_UNPREPARE: 	return wodUnprepare	(wDevID, (LPWAVEHDR)dwParam1, 		dwParam2);
+    case WODM_GETDEVCAPS:	return wodGetDevCaps	(wDevID, (LPWAVEOUTCAPSA)dwParam1,	dwParam2);
+    case WODM_GETNUMDEVS:	return wodGetNumDevs	();
+    case WODM_GETPITCH:	 	return MMSYSERR_NOTSUPPORTED;
+    case WODM_SETPITCH:	 	return MMSYSERR_NOTSUPPORTED;
+    case WODM_GETPLAYBACKRATE:	return MMSYSERR_NOTSUPPORTED;
+    case WODM_SETPLAYBACKRATE:	return MMSYSERR_NOTSUPPORTED;
+    case WODM_GETVOLUME:	return wodGetVolume	(wDevID, (LPDWORD)dwParam1);
+    case WODM_SETVOLUME:	return wodSetVolume	(wDevID, dwParam1);
+    case WODM_RESTART:		return wodRestart	(wDevID);
+    case WODM_RESET:		return wodReset		(wDevID);
+
+    case DRV_QUERYDSOUNDIFACE:	return wodDsCreate(wDevID, (PIDSDRIVER*)dwParam1);
+    default:
+	FIXME("unknown message %d!\n", wMsg);
+    }
+    return MMSYSERR_NOTSUPPORTED;
+}
+
+/*======================================================================*
+ *                  Low level DSOUND implementation			*
+ *======================================================================*/
+
+typedef struct IDsDriverImpl IDsDriverImpl;
+typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
+
+struct IDsDriverImpl
+{
+    /* IUnknown fields */
+    ICOM_VFIELD(IDsDriver);
+    DWORD		ref;
+    /* IDsDriverImpl fields */
+    UINT		wDevID;
+    IDsDriverBufferImpl*primary;
+};
+
+struct IDsDriverBufferImpl
+{
+    /* IUnknown fields */
+    ICOM_VFIELD(IDsDriverBuffer);
+    DWORD		ref;
+    /* IDsDriverBufferImpl fields */
+    IDsDriverImpl*	drv;
+    DWORD		buflen;
+};
+
+static HRESULT DSDB_UnmapPrimary(IDsDriverBufferImpl *dsdb)
+{
+    WINE_WAVEOUT *wwo = &(WOutDev[dsdb->drv->wDevID]);
+    if (wwo->mmap_buffer) {
+	if (snd_pcm_munmap(wwo->handle, SND_PCM_CHANNEL_PLAYBACK) < 0) {
+	    ERR("(%p): Could not unmap sound device (errno=%d)\n", dsdb, errno);
+	    return DSERR_GENERIC;
+	}
+	wwo->mmap_buffer = wwo->mmap_control = NULL;
+	TRACE("(%p): sound device unmapped\n", dsdb);
+    }
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_QueryInterface(PIDSDRIVERBUFFER iface, REFIID riid, LPVOID *ppobj)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    FIXME("(): stub!\n");
+    return DSERR_UNSUPPORTED;
+}
+
+static ULONG WINAPI IDsDriverBufferImpl_AddRef(PIDSDRIVERBUFFER iface)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    This->ref++;
+    return This->ref;
+}
+
+static ULONG WINAPI IDsDriverBufferImpl_Release(PIDSDRIVERBUFFER iface)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    if (--This->ref)
+	return This->ref;
+    if (This == This->drv->primary)
+	This->drv->primary = NULL;
+    DSDB_UnmapPrimary(This);
+    HeapFree(GetProcessHeap(),0,This);
+    return 0;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Lock(PIDSDRIVERBUFFER iface,
+					       LPVOID*ppvAudio1,LPDWORD pdwLen1,
+					       LPVOID*ppvAudio2,LPDWORD pdwLen2,
+					       DWORD dwWritePosition,DWORD dwWriteLen,
+					       DWORD dwFlags)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    /* FIXME: we need to implement it */
+    TRACE("(%p)\n",iface);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Unlock(PIDSDRIVERBUFFER iface,
+						 LPVOID pvAudio1,DWORD dwLen1,
+						 LPVOID pvAudio2,DWORD dwLen2)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    TRACE("(%p)\n",iface);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetFormat(PIDSDRIVERBUFFER iface,
+						    LPWAVEFORMATEX pwfx)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+
+    TRACE("(%p,%p)\n",iface,pwfx);
+    /* On our request (GetDriverDesc flags), DirectSound has by now used
+     * waveOutClose/waveOutOpen to set the format...
+     * unfortunately, this means our mmap() is now gone...
+     * so we need to somehow signal to our DirectSound implementation
+     * that it should completely recreate this HW buffer...
+     * this unexpected error code should do the trick... */
+    return DSERR_BUFFERLOST;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetFrequency(PIDSDRIVERBUFFER iface, DWORD dwFreq)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    TRACE("(%p,%ld): stub\n",iface,dwFreq);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetVolumePan(PIDSDRIVERBUFFER iface, PDSVOLUMEPAN pVolPan)
+{
+    /* ICOM_THIS(IDsDriverBufferImpl,iface); */
+    FIXME("(%p,%p): stub!\n",iface,pVolPan);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_SetPosition(PIDSDRIVERBUFFER iface, DWORD dwNewPos)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    TRACE("(%p,%ld): stub\n",iface,dwNewPos);
+    return DSERR_UNSUPPORTED;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_GetPosition(PIDSDRIVERBUFFER iface,
+						      LPDWORD lpdwPlay, LPDWORD lpdwWrite)
+{
+#if 0
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+    TODO;
+    count_info info;
+    DWORD ptr;
+
+    TRACE("(%p)\n",iface);
+    if (WOutDev[This->drv->wDevID].handle == NULL) {
+	ERR("device not open, but accessing?\n");
+	return DSERR_UNINITIALIZED;
+    }
+    if (ioctl(WOutDev[This->drv->wDevID].unixdev, SNDCTL_DSP_GETOPTR, &info) < 0) {
+	ERR("ioctl failed (%d)\n", errno);
+	return DSERR_GENERIC;
+    }
+    ptr = info.ptr & ~3; /* align the pointer, just in case */
+    if (lpdwPlay) *lpdwPlay = ptr;
+    if (lpdwWrite) {
+	/* add some safety margin (not strictly necessary, but...) */
+	if (WOutDev[This->drv->wDevID].caps.dwSupport & WAVECAPS_SAMPLEACCURATE)
+	    *lpdwWrite = ptr + 32;
+	else
+	    *lpdwWrite = ptr + WOutDev[This->drv->wDevID].dwFragmentSize;
+	while (*lpdwWrite > This->buflen)
+	    *lpdwWrite -= This->buflen;
+    
+    }
+#endif
+    TRACE("playpos=%ld, writepos=%ld\n", lpdwPlay?*lpdwPlay:0, lpdwWrite?*lpdwWrite:0);
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Play(PIDSDRIVERBUFFER iface, DWORD dwRes1, DWORD dwRes2, DWORD dwFlags)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+
+    TRACE("(%p,%lx,%lx,%lx)\n",iface,dwRes1,dwRes2,dwFlags);
+
+    /* FIXME: error handling */
+    snd_pcm_playback_go(WOutDev[This->drv->wDevID].handle);
+
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverBufferImpl_Stop(PIDSDRIVERBUFFER iface)
+{
+    ICOM_THIS(IDsDriverBufferImpl,iface);
+
+    TRACE("(%p)\n",iface);
+
+    /* no more playing */
+    /* FIXME: error handling */
+    snd_pcm_playback_drain(WOutDev[This->drv->wDevID].handle);
+
+    /* Most ALSA drivers just can't stop the playback without closing the device...
+     * so we need to somehow signal to our DirectSound implementation
+     * that it should completely recreate this HW buffer...
+     * this unexpected error code should do the trick... */
+    return DSERR_BUFFERLOST;
+}
+
+static ICOM_VTABLE(IDsDriverBuffer) dsdbvt =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    IDsDriverBufferImpl_QueryInterface,
+    IDsDriverBufferImpl_AddRef,
+    IDsDriverBufferImpl_Release,
+    IDsDriverBufferImpl_Lock,
+    IDsDriverBufferImpl_Unlock,
+    IDsDriverBufferImpl_SetFormat,
+    IDsDriverBufferImpl_SetFrequency,
+    IDsDriverBufferImpl_SetVolumePan,
+    IDsDriverBufferImpl_SetPosition,
+    IDsDriverBufferImpl_GetPosition,
+    IDsDriverBufferImpl_Play,
+    IDsDriverBufferImpl_Stop
+};
+
+static HRESULT WINAPI IDsDriverImpl_QueryInterface(PIDSDRIVER iface, REFIID riid, LPVOID *ppobj)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    FIXME("(%p): stub!\n",iface);
+    return DSERR_UNSUPPORTED;
+}
+
+static ULONG WINAPI IDsDriverImpl_AddRef(PIDSDRIVER iface)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    This->ref++;
+    return This->ref;
+}
+
+static ULONG WINAPI IDsDriverImpl_Release(PIDSDRIVER iface)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    if (--This->ref)
+	return This->ref;
+    HeapFree(GetProcessHeap(),0,This);
+    return 0;
+}
+
+static HRESULT WINAPI IDsDriverImpl_GetDriverDesc(PIDSDRIVER iface, PDSDRIVERDESC pDesc)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    TRACE("(%p,%p)\n",iface,pDesc);
+    pDesc->dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT |
+	DSDDESC_USESYSTEMMEMORY;
+    strcpy(pDesc->szDesc,"WineALSA DirectSound Driver");
+    strcpy(pDesc->szDrvName,"winealsa.drv");
+    pDesc->dnDevNode		= WOutDev[This->wDevID].waveDesc.dnDevNode;
+    pDesc->wVxdId		= 0; 
+    pDesc->wReserved		= 0;
+    pDesc->ulDeviceNum		= This->wDevID;
+    pDesc->dwHeapType		= DSDHEAP_NOHEAP;
+    pDesc->pvDirectDrawHeap	= NULL;
+    pDesc->dwMemStartAddress	= 0;
+    pDesc->dwMemEndAddress	= 0;
+    pDesc->dwMemAllocExtra	= 0;
+    pDesc->pvReserved1		= NULL;
+    pDesc->pvReserved2		= NULL;
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_Open(PIDSDRIVER iface)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+
+    TRACE("(%p)\n",iface);
+    /* FIXME: error handling */
+    snd_pcm_channel_prepare(WOutDev[This->wDevID].handle, SND_PCM_CHANNEL_PLAYBACK);
+
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_Close(PIDSDRIVER iface)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    TRACE("(%p)\n",iface);
+    if (This->primary) {
+	ERR("problem with DirectSound: primary not released\n");
+	return DSERR_GENERIC;
+    }
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_GetCaps(PIDSDRIVER iface, PDSDRIVERCAPS pCaps)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    TRACE("(%p,%p)\n",iface,pCaps);
+    memset(pCaps, 0, sizeof(*pCaps));
+    /* FIXME: need to check actual capabilities */
+    pCaps->dwFlags = DSCAPS_PRIMARYMONO | DSCAPS_PRIMARYSTEREO |
+	DSCAPS_PRIMARY8BIT | DSCAPS_PRIMARY16BIT;
+    pCaps->dwPrimaryBuffers = 1;
+    /* the other fields only apply to secondary buffers, which we don't support
+     * (unless we want to mess with wavetable synthesizers and MIDI) */
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_CreateSoundBuffer(PIDSDRIVER iface,
+						      LPWAVEFORMATEX pwfx,
+						      DWORD dwFlags, DWORD dwCardAddress,
+						      LPDWORD pdwcbBufferSize,
+						      LPBYTE *ppbBuffer,
+						      LPVOID *ppvObj)
+{
+    ICOM_THIS(IDsDriverImpl,iface);
+    IDsDriverBufferImpl** ippdsdb = (IDsDriverBufferImpl**)ppvObj;
+    WINE_WAVEOUT *wwo = &(WOutDev[This->wDevID]);
+    struct snd_pcm_channel_setup setup;
+
+    TRACE("(%p,%p,%lx,%lx)\n",iface,pwfx,dwFlags,dwCardAddress);
+    /* we only support primary buffers */
+    if (!(dwFlags & DSBCAPS_PRIMARYBUFFER))
+	return DSERR_UNSUPPORTED;
+    if (This->primary)
+	return DSERR_ALLOCATED;
+    if (dwFlags & (DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN))
+	return DSERR_CONTROLUNAVAIL;
+
+    *ippdsdb = (IDsDriverBufferImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverBufferImpl));
+    if (*ippdsdb == NULL)
+	return DSERR_OUTOFMEMORY;
+    ICOM_VTBL(*ippdsdb) = &dsdbvt;
+    (*ippdsdb)->ref	= 1;
+    (*ippdsdb)->drv	= This;
+
+    if (!wwo->mmap_buffer) {
+        if (snd_pcm_mmap(wwo->handle, SND_PCM_CHANNEL_PLAYBACK, &wwo->mmap_control, &wwo->mmap_buffer))
+        {
+	    ERR("(%p): Could not map sound device for direct access (%s)\n", *ippdsdb, snd_strerror(errno));
+	    return DSERR_GENERIC;
+	}
+
+	setup.mode = SND_PCM_MODE_BLOCK;
+	setup.channel = SND_PCM_CHANNEL_PLAYBACK;
+	if (snd_pcm_channel_setup(wwo->handle, &setup) < 0) {
+            ERR("Unable to obtain setup\n");
+            /* FIXME: resource cleanup */
+            return DSERR_GENERIC;
+	}
+        wwo->mmap_block_size = setup.buf.block.frag_size;
+        wwo->mmap_block_number = setup.buf.block.frags;
+
+	TRACE("(%p): sound device has been mapped for direct access at %p, size=%d\n", 
+              *ippdsdb, wwo->mmap_buffer, setup.buf.block.frags * setup.buf.block.frag_size);
+#if 0
+	/* for some reason, es1371 and sblive! sometimes have junk in here.
+	 * clear it, or we get junk noise */
+	/* some libc implementations are buggy: their memset reads from the buffer...
+	 * to work around it, we have to zero the block by hand. We don't do the expected:
+	 * memset(wwo->mapping, 0, wwo->maplen); 
+	 */
+	{
+	    char*	p1 = wwo->mapping;
+	    unsigned	len = wwo->maplen;
+
+	    if (len >= 16) /* so we can have at least a 4 long area to store... */
+	    {
+		/* the mmap:ed value is (at least) dword aligned
+		 * so, start filling the complete unsigned long:s 
+		 */
+		int		b = len >> 2;
+		unsigned long*	p4 = (unsigned long*)p1;
+
+		while (b--) *p4++ = 0;
+		/* prepare for filling the rest */
+		len &= 3;
+		p1 = (unsigned char*)p4;
+	    }
+	    /* in all cases, fill the remaining bytes */
+	    while (len-- != 0) *p1++ = 0;
+	}
+#endif
+    }
+
+    /* primary buffer is ready to go */
+    *pdwcbBufferSize	= wwo->mmap_block_size * wwo->mmap_block_number;
+    *ppbBuffer		= wwo->mmap_buffer;
+
+    This->primary = *ippdsdb;
+
+    return DS_OK;
+}
+
+static HRESULT WINAPI IDsDriverImpl_DuplicateSoundBuffer(PIDSDRIVER iface,
+							 PIDSDRIVERBUFFER pBuffer,
+							 LPVOID *ppvObj)
+{
+    /* ICOM_THIS(IDsDriverImpl,iface); */
+    TRACE("(%p,%p): stub\n",iface,pBuffer);
+    return DSERR_INVALIDCALL;
+}
+
+static ICOM_VTABLE(IDsDriver) dsdvt =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    IDsDriverImpl_QueryInterface,
+    IDsDriverImpl_AddRef,
+    IDsDriverImpl_Release,
+    IDsDriverImpl_GetDriverDesc,
+    IDsDriverImpl_Open,
+    IDsDriverImpl_Close,
+    IDsDriverImpl_GetCaps,
+    IDsDriverImpl_CreateSoundBuffer,
+    IDsDriverImpl_DuplicateSoundBuffer
+};
+
+static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
+{
+    IDsDriverImpl** idrv = (IDsDriverImpl**)drv;
+
+    /* the HAL isn't much better than the HEL if we can't do mmap() */
+    if (!(WOutDev[wDevID].caps.dwSupport & WAVECAPS_DIRECTSOUND)) {
+	ERR("DirectSound flag not set\n");
+	MESSAGE("This sound card's driver does not support direct access\n");
+	MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
+	return MMSYSERR_NOTSUPPORTED;
+    }
+
+    *idrv = (IDsDriverImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverImpl));
+    if (!*idrv)
+	return MMSYSERR_NOMEM;
+    ICOM_VTBL(*idrv)	= &dsdvt;
+    (*idrv)->ref	= 1;
+
+    (*idrv)->wDevID	= wDevID;
+    (*idrv)->primary	= NULL;
+    return MMSYSERR_NOERROR;
+}
+
+/* we don't need a default wodMessage for audio when we don't have ALSA, the
+ * audio.c file will provide it for us
+ */
+#endif /* HAVE_ALSA && interface == 0.5 */
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/winmm/winealsa/winealsa.drv.spec	Wed May 15 21:35:30 2002
@@ -0,0 +1,2 @@
+@ stdcall DriverProc(long long long long long) ALSA_DriverProc
+@ stdcall wodMessage(long long long long long) ALSA_wodMessage
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/winmm/winealsa/.cvsignore	Tue Jan 29 07:45:40 2002
@@ -0,0 +1,2 @@
+Makefile
+winealsa.drv.spec.c

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux