Get rid of the non-standard ICOM_VFIELD macro.

[wine/testsucceed.git] / dlls / winmm / winealsa / audio_05.c

/* -*- 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
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"

#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <errno.h>
#include <fcntl.h>
#ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#ifdef HAVE_SYS_MMAN_H
# include <sys/mman.h>
#endif
#include "windef.h"
#include "winbase.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("-\n");
    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)
{
#if 0
    int         mixer;
#endif
    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);
#else
    volume = 0x2020;
#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)
{
#if 0
    int         mixer;
#endif
    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.@)
 */
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 */
    IDsDriverVtbl      *lpVtbl;
    DWORD               ref;
    /* IDsDriverImpl fields */
    UINT                wDevID;
    IDsDriverBufferImpl*primary;
};

struct IDsDriverBufferImpl
{
    /* IUnknown fields */
    IDsDriverBufferVtbl *lpVtbl;
    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;
    (*ippdsdb)->lpVtbl  = &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;
    (*idrv)->lpVtbl     = &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 */