git.oblomov.eu Git - wine/blob - dlls/winmm/winealsa/audio.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /*
   3  * Sample Wine Driver for Advanced Linux Sound System (ALSA)
   4  *      Based on version <final> of the ALSA API
   5  *
   6  * Copyright    2002 Eric Pouech
   7  *              2002 Marco Pietrobono
   8  *              2003 Christian Costa : WaveIn support
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 /* unless someone makes a wineserver kernel module, Unix pipes are faster than win32 events */
  26 #define USE_PIPE_SYNC
  27
  28 #include "config.h"
  29 #include "wine/port.h"
  30
  31 #include <stdlib.h>
  32 #include <stdarg.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #ifdef HAVE_UNISTD_H
  36 # include <unistd.h>
  37 #endif
  38 #include <errno.h>
  39 #include <limits.h>
  40 #include <fcntl.h>
  41 #ifdef HAVE_SYS_IOCTL_H
  42 # include <sys/ioctl.h>
  43 #endif
  44 #ifdef HAVE_SYS_MMAN_H
  45 # include <sys/mman.h>
  46 #endif
  47 #include "windef.h"
  48 #include "winbase.h"
  49 #include "wingdi.h"
  50 #include "winerror.h"
  51 #include "winuser.h"
  52 #include "winnls.h"
  53 #include "winreg.h"
  54 #include "mmddk.h"
  55 #include "dsound.h"
  56 #include "dsdriver.h"
  57 #define ALSA_PCM_OLD_HW_PARAMS_API
  58 #define ALSA_PCM_OLD_SW_PARAMS_API
  59 #include "alsa.h"
  60 #include "wine/library.h"
  61 #include "wine/debug.h"
  62
  63 WINE_DEFAULT_DEBUG_CHANNEL(wave);
  64
  65
  66 #if defined(HAVE_ALSA) && ((SND_LIB_MAJOR == 0 && SND_LIB_MINOR >= 9) || SND_LIB_MAJOR >= 1)
  67
  68 /* internal ALSALIB functions */
  69 snd_pcm_uframes_t _snd_pcm_mmap_hw_ptr(snd_pcm_t *pcm);
  70
  71
  72 #define MAX_WAVEOUTDRV  (1)
  73 #define MAX_WAVEINDRV   (1)
  74
  75 /* state diagram for waveOut writing:
  76  *
  77  * +---------+-------------+---------------+---------------------------------+
  78  * |  state  |  function   |     event     |            new state            |
  79  * +---------+-------------+---------------+---------------------------------+
  80  * |         | open()      |               | STOPPED                         |
  81  * | PAUSED  | write()     |               | PAUSED                          |
  82  * | STOPPED | write()     | <thrd create> | PLAYING                         |
  83  * | PLAYING | write()     | HEADER        | PLAYING                         |
  84  * | (other) | write()     | <error>       |                                 |
  85  * | (any)   | pause()     | PAUSING       | PAUSED                          |
  86  * | PAUSED  | restart()   | RESTARTING    | PLAYING (if no thrd => STOPPED) |
  87  * | (any)   | reset()     | RESETTING     | STOPPED                         |
  88  * | (any)   | close()     | CLOSING       | CLOSED                          |
  89  * +---------+-------------+---------------+---------------------------------+
  90  */
  91
  92 /* states of the playing device */
  93 #define WINE_WS_PLAYING         0
  94 #define WINE_WS_PAUSED          1
  95 #define WINE_WS_STOPPED         2
  96 #define WINE_WS_CLOSED          3
  97
  98 /* events to be send to device */
  99 enum win_wm_message {
 100     WINE_WM_PAUSING = WM_USER + 1, WINE_WM_RESTARTING, WINE_WM_RESETTING, WINE_WM_HEADER,
 101     WINE_WM_UPDATE, WINE_WM_BREAKLOOP, WINE_WM_CLOSING, WINE_WM_STARTING, WINE_WM_STOPPING
 102 };
 103
 104 #ifdef USE_PIPE_SYNC
 105 #define SIGNAL_OMR(omr) do { int x = 0; write((omr)->msg_pipe[1], &x, sizeof(x)); } while (0)
 106 #define CLEAR_OMR(omr) do { int x = 0; read((omr)->msg_pipe[0], &x, sizeof(x)); } while (0)
 107 #define RESET_OMR(omr) do { } while (0)
 108 #define WAIT_OMR(omr, sleep) \
 109   do { struct pollfd pfd; pfd.fd = (omr)->msg_pipe[0]; \
 110        pfd.events = POLLIN; poll(&pfd, 1, sleep); } while (0)
 111 #else
 112 #define SIGNAL_OMR(omr) do { SetEvent((omr)->msg_event); } while (0)
 113 #define CLEAR_OMR(omr) do { } while (0)
 114 #define RESET_OMR(omr) do { ResetEvent((omr)->msg_event); } while (0)
 115 #define WAIT_OMR(omr, sleep) \
 116   do { WaitForSingleObject((omr)->msg_event, sleep); } while (0)
 117 #endif
 118
 119 typedef struct {
 120     enum win_wm_message         msg;    /* message identifier */
 121     DWORD                       param;  /* parameter for this message */
 122     HANDLE                      hEvent; /* if message is synchronous, handle of event for synchro */
 123 } ALSA_MSG;
 124
 125 /* implement an in-process message ring for better performance
 126  * (compared to passing thru the server)
 127  * this ring will be used by the input (resp output) record (resp playback) routine
 128  */
 129 #define ALSA_RING_BUFFER_INCREMENT      64
 130 typedef struct {
 131     ALSA_MSG                    * messages;
 132     int                         ring_buffer_size;
 133     int                         msg_tosave;
 134     int                         msg_toget;
 135 #ifdef USE_PIPE_SYNC
 136     int                         msg_pipe[2];
 137 #else
 138     HANDLE                      msg_event;
 139 #endif
 140     CRITICAL_SECTION            msg_crst;
 141 } ALSA_MSG_RING;
 142
 143 typedef struct {
 144     /* Windows information */
 145     volatile int                state;                  /* one of the WINE_WS_ manifest constants */
 146     WAVEOPENDESC                waveDesc;
 147     WORD                        wFlags;
 148     PCMWAVEFORMAT               format;
 149     WAVEOUTCAPSA                caps;
 150
 151     /* ALSA information (ALSA 0.9/1.x uses two different devices for playback/capture) */
 152     char*                      device;
 153     snd_pcm_t*                  p_handle;                 /* handle to ALSA playback device */
 154     snd_pcm_t*                  c_handle;                 /* handle to ALSA capture device */
 155     snd_pcm_hw_params_t *       hw_params;              /* ALSA Hw params */
 156
 157     snd_ctl_t *                 ctl;                    /* control handle for the playback volume */
 158     snd_ctl_elem_id_t *         playback_eid;           /* element id of the playback volume control */
 159     snd_ctl_elem_value_t *      playback_evalue;        /* element value of the playback volume control */
 160     snd_ctl_elem_info_t *       playback_einfo;         /* element info of the playback volume control */
 161
 162     snd_pcm_sframes_t           (*write)(snd_pcm_t *, const void *, snd_pcm_uframes_t );
 163
 164     struct pollfd               *ufds;
 165     int                         count;
 166
 167     DWORD                       dwBufferSize;           /* size of whole ALSA buffer in bytes */
 168     LPWAVEHDR                   lpQueuePtr;             /* start of queued WAVEHDRs (waiting to be notified) */
 169     LPWAVEHDR                   lpPlayPtr;              /* start of not yet fully played buffers */
 170
 171     LPWAVEHDR                   lpLoopPtr;              /* pointer of first buffer in loop, if any */
 172     DWORD                       dwLoops;                /* private copy of loop counter */
 173
 174     DWORD                       dwPlayedTotal;
 175
 176     /* synchronization stuff */
 177     HANDLE                      hStartUpEvent;
 178     HANDLE                      hThread;
 179     DWORD                       dwThreadID;
 180     ALSA_MSG_RING               msgRing;
 181
 182     /* DirectSound stuff */
 183     DSDRIVERDESC                ds_desc;
 184     GUID                        ds_guid;
 185 } WINE_WAVEOUT;
 186
 187 typedef struct {
 188     /* Windows information */
 189     volatile int                state;                  /* one of the WINE_WS_ manifest constants */
 190     WAVEOPENDESC                waveDesc;
 191     WORD                        wFlags;
 192     PCMWAVEFORMAT               format;
 193     WAVEOUTCAPSA                caps;
 194
 195     /* ALSA information (ALSA 0.9/1.x uses two different devices for playback/capture) */
 196     char*                      device;
 197     snd_pcm_t*                  p_handle;                 /* handle to ALSA playback device */
 198     snd_pcm_t*                  c_handle;                 /* handle to ALSA capture device */
 199     snd_pcm_hw_params_t *       hw_params;              /* ALSA Hw params */
 200
 201     snd_ctl_t *                 ctl;                    /* control handle for the playback volume */
 202     snd_ctl_elem_id_t *         playback_eid;           /* element id of the playback volume control */
 203     snd_ctl_elem_value_t *      playback_evalue;        /* element value of the playback volume control */
 204     snd_ctl_elem_info_t *       playback_einfo;         /* element info of the playback volume control */
 205
 206     snd_pcm_sframes_t           (*read)(snd_pcm_t *, void *, snd_pcm_uframes_t );
 207
 208     struct pollfd               *ufds;
 209     int                         count;
 210
 211     DWORD                       dwPeriodSize;           /* size of OSS buffer period */
 212     DWORD                       dwBufferSize;           /* size of whole ALSA buffer in bytes */
 213     LPWAVEHDR                   lpQueuePtr;             /* start of queued WAVEHDRs (waiting to be notified) */
 214     LPWAVEHDR                   lpPlayPtr;              /* start of not yet fully played buffers */
 215
 216     LPWAVEHDR                   lpLoopPtr;              /* pointer of first buffer in loop, if any */
 217     DWORD                       dwLoops;                /* private copy of loop counter */
 218
 219     /*DWORD                     dwPlayedTotal; */
 220     DWORD                       dwTotalRecorded;
 221
 222     /* synchronization stuff */
 223     HANDLE                      hStartUpEvent;
 224     HANDLE                      hThread;
 225     DWORD                       dwThreadID;
 226     ALSA_MSG_RING               msgRing;
 227
 228     /* DirectSound stuff */
 229     DSDRIVERDESC                ds_desc;
 230     GUID                        ds_guid;
 231 } WINE_WAVEIN;
 232
 233 static WINE_WAVEOUT     WOutDev   [MAX_WAVEOUTDRV];
 234 static DWORD            ALSA_WodNumDevs;
 235 static WINE_WAVEIN      WInDev   [MAX_WAVEINDRV];
 236 static DWORD            ALSA_WidNumDevs;
 237
 238 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv);
 239 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc);
 240 static DWORD wodDsGuid(UINT wDevID, LPGUID pGuid);
 241
 242 /* These strings used only for tracing */
 243 #if 1
 244 static const char *wodPlayerCmdString[] = {
 245     "WINE_WM_PAUSING",
 246     "WINE_WM_RESTARTING",
 247     "WINE_WM_RESETTING",
 248     "WINE_WM_HEADER",
 249     "WINE_WM_UPDATE",
 250     "WINE_WM_BREAKLOOP",
 251     "WINE_WM_CLOSING",
 252     "WINE_WM_STARTING",
 253     "WINE_WM_STOPPING",
 254 };
 255 #endif
 256
 257 /*======================================================================*
 258  *                  Low level WAVE implementation                       *
 259  *======================================================================*/
 260
 261 /**************************************************************************
 262  *                      ALSA_InitializeVolumeCtl                [internal]
 263  *
 264  * used to initialize the PCM Volume Control
 265  */
 266 static int ALSA_InitializeVolumeCtl(WINE_WAVEOUT * wwo)
 267 {
 268     snd_ctl_t *                 ctl = NULL;
 269     snd_ctl_card_info_t *       cardinfo;
 270     snd_ctl_elem_list_t *       elemlist;
 271     snd_ctl_elem_id_t *         e_id;
 272     snd_ctl_elem_info_t *       einfo;
 273     snd_hctl_t *                hctl = NULL;
 274     snd_hctl_elem_t *           elem;
 275     int                         nCtrls;
 276     int                         i;
 277
 278     snd_ctl_card_info_alloca(&cardinfo);
 279     memset(cardinfo,0,snd_ctl_card_info_sizeof());
 280
 281     snd_ctl_elem_list_alloca(&elemlist);
 282     memset(elemlist,0,snd_ctl_elem_list_sizeof());
 283
 284     snd_ctl_elem_id_alloca(&e_id);
 285     memset(e_id,0,snd_ctl_elem_id_sizeof());
 286
 287     snd_ctl_elem_info_alloca(&einfo);
 288     memset(einfo,0,snd_ctl_elem_info_sizeof());
 289
 290 #define EXIT_ON_ERROR(f,txt) do \
 291 { \
 292     int err; \
 293     if ( (err = (f) ) < 0) \
 294     { \
 295         ERR(txt ": %s\n", snd_strerror(err)); \
 296         if (hctl) \
 297             snd_hctl_close(hctl); \
 298         if (ctl) \
 299             snd_ctl_close(ctl); \
 300         return -1; \
 301     } \
 302 } while(0)
 303
 304     EXIT_ON_ERROR( snd_ctl_open(&ctl,"hw",0) , "ctl open failed" );
 305     EXIT_ON_ERROR( snd_ctl_card_info(ctl, cardinfo), "card info failed");
 306     EXIT_ON_ERROR( snd_ctl_elem_list(ctl, elemlist), "elem list failed");
 307
 308     nCtrls = snd_ctl_elem_list_get_count(elemlist);
 309
 310     EXIT_ON_ERROR( snd_hctl_open(&hctl,"hw",0), "hctl open failed");
 311     EXIT_ON_ERROR( snd_hctl_load(hctl), "hctl load failed" );
 312
 313     elem=snd_hctl_first_elem(hctl);
 314     for ( i= 0; i<nCtrls; i++) {
 315
 316         memset(e_id,0,snd_ctl_elem_id_sizeof());
 317
 318         snd_hctl_elem_get_id(elem,e_id);
 319 /*
 320         TRACE("ctl: #%d '%s'%d\n",
 321                                    snd_ctl_elem_id_get_numid(e_id),
 322                                    snd_ctl_elem_id_get_name(e_id),
 323                                    snd_ctl_elem_id_get_index(e_id));
 324 */
 325         if ( !strcmp("PCM Playback Volume", snd_ctl_elem_id_get_name(e_id)) )
 326         {
 327             EXIT_ON_ERROR( snd_hctl_elem_info(elem,einfo), "hctl elem info failed" );
 328
 329             /* few sanity checks... you'll never know... */
 330             if ( snd_ctl_elem_info_get_type(einfo) != SND_CTL_ELEM_TYPE_INTEGER )
 331                 WARN("playback volume control is not an integer\n");
 332             if ( !snd_ctl_elem_info_is_readable(einfo) )
 333                 WARN("playback volume control is readable\n");
 334             if ( !snd_ctl_elem_info_is_writable(einfo) )
 335                 WARN("playback volume control is readable\n");
 336
 337             TRACE("   ctrl range: min=%ld  max=%ld  step=%ld\n",
 338                  snd_ctl_elem_info_get_min(einfo),
 339                  snd_ctl_elem_info_get_max(einfo),
 340                  snd_ctl_elem_info_get_step(einfo));
 341
 342             EXIT_ON_ERROR( snd_ctl_elem_id_malloc(&wwo->playback_eid), "elem id malloc failed" );
 343             EXIT_ON_ERROR( snd_ctl_elem_info_malloc(&wwo->playback_einfo), "elem info malloc failed" );
 344             EXIT_ON_ERROR( snd_ctl_elem_value_malloc(&wwo->playback_evalue), "elem value malloc failed" );
 345
 346             /* ok, now we can safely save these objects for later */
 347             snd_ctl_elem_id_copy(wwo->playback_eid, e_id);
 348             snd_ctl_elem_info_copy(wwo->playback_einfo, einfo);
 349             snd_ctl_elem_value_set_id(wwo->playback_evalue, wwo->playback_eid);
 350             wwo->ctl = ctl;
 351         }
 352
 353         elem=snd_hctl_elem_next(elem);
 354     }
 355     snd_hctl_close(hctl);
 356 #undef EXIT_ON_ERROR
 357     return 0;
 358 }
 359
 360 /**************************************************************************
 361  *                      ALSA_XRUNRecovery               [internal]
 362  *
 363  * used to recovery from XRUN errors (buffer underflow/overflow)
 364  */
 365 static int ALSA_XRUNRecovery(WINE_WAVEOUT * wwo, int err)
 366 {
 367     if (err == -EPIPE) {    /* under-run */
 368         err = snd_pcm_prepare(wwo->p_handle);
 369         if (err < 0)
 370              ERR( "underrun recovery failed. prepare failed: %s\n", snd_strerror(err));
 371         return 0;
 372     } else if (err == -ESTRPIPE) {
 373         while ((err = snd_pcm_resume(wwo->p_handle)) == -EAGAIN)
 374             sleep(1);       /* wait until the suspend flag is released */
 375             if (err < 0) {
 376                 err = snd_pcm_prepare(wwo->p_handle);
 377                 if (err < 0)
 378                     ERR("recovery from suspend failed, prepare failed: %s\n", snd_strerror(err));
 379             }
 380             return 0;
 381     }
 382     return err;
 383 }
 384
 385 /**************************************************************************
 386  *                      ALSA_TraceParameters            [internal]
 387  *
 388  * used to trace format changes, hw and sw parameters
 389  */
 390 static void ALSA_TraceParameters(snd_pcm_hw_params_t * hw_params, snd_pcm_sw_params_t * sw, int full)
 391 {
 392     snd_pcm_format_t   format = snd_pcm_hw_params_get_format(hw_params);
 393     snd_pcm_access_t   access = snd_pcm_hw_params_get_access(hw_params);
 394
 395 #define X(x) ((x)? "true" : "false")
 396     if (full)
 397         TRACE("FLAGS: sampleres=%s overrng=%s pause=%s resume=%s syncstart=%s batch=%s block=%s double=%s "
 398               "halfd=%s joint=%s \n",
 399               X(snd_pcm_hw_params_can_mmap_sample_resolution(hw_params)),
 400               X(snd_pcm_hw_params_can_overrange(hw_params)),
 401               X(snd_pcm_hw_params_can_pause(hw_params)),
 402               X(snd_pcm_hw_params_can_resume(hw_params)),
 403               X(snd_pcm_hw_params_can_sync_start(hw_params)),
 404               X(snd_pcm_hw_params_is_batch(hw_params)),
 405               X(snd_pcm_hw_params_is_block_transfer(hw_params)),
 406               X(snd_pcm_hw_params_is_double(hw_params)),
 407               X(snd_pcm_hw_params_is_half_duplex(hw_params)),
 408               X(snd_pcm_hw_params_is_joint_duplex(hw_params)));
 409 #undef X
 410
 411     if (access >= 0)
 412         TRACE("access=%s\n", snd_pcm_access_name(access));
 413     else
 414     {
 415         snd_pcm_access_mask_t * acmask;
 416         snd_pcm_access_mask_alloca(&acmask);
 417         snd_pcm_hw_params_get_access_mask(hw_params, acmask);
 418         for ( access = SND_PCM_ACCESS_MMAP_INTERLEAVED; access <= SND_PCM_ACCESS_LAST; access++)
 419             if (snd_pcm_access_mask_test(acmask, access))
 420                 TRACE("access=%s\n", snd_pcm_access_name(access));
 421     }
 422
 423     if (format >= 0)
 424     {
 425         TRACE("format=%s\n", snd_pcm_format_name(format));
 426
 427     }
 428     else
 429     {
 430         snd_pcm_format_mask_t *     fmask;
 431
 432         snd_pcm_format_mask_alloca(&fmask);
 433         snd_pcm_hw_params_get_format_mask(hw_params, fmask);
 434         for ( format = SND_PCM_FORMAT_S8; format <= SND_PCM_FORMAT_LAST ; format++)
 435             if ( snd_pcm_format_mask_test(fmask, format) )
 436                 TRACE("format=%s\n", snd_pcm_format_name(format));
 437     }
 438
 439 #define X(x) do { \
 440 int n = snd_pcm_hw_params_get_##x(hw_params); \
 441 if (n<0) \
 442     TRACE(#x "_min=%ld " #x "_max=%ld\n", \
 443         (long int)snd_pcm_hw_params_get_##x##_min(hw_params), \
 444         (long int)snd_pcm_hw_params_get_##x##_max(hw_params)); \
 445 else \
 446     TRACE(#x "=%d\n", n); \
 447 } while(0)
 448     X(channels);
 449     X(buffer_size);
 450 #undef X
 451
 452 #define X(x) do { \
 453 int n = snd_pcm_hw_params_get_##x(hw_params,0); \
 454 if (n<0) \
 455     TRACE(#x "_min=%ld " #x "_max=%ld\n", \
 456         (long int)snd_pcm_hw_params_get_##x##_min(hw_params,0), \
 457         (long int)snd_pcm_hw_params_get_##x##_max(hw_params,0)); \
 458 else \
 459     TRACE(#x "=%d\n", n); \
 460 } while(0)
 461     X(rate);
 462     X(buffer_time);
 463     X(periods);
 464     X(period_size);
 465     X(period_time);
 466     X(tick_time);
 467 #undef X
 468
 469     if (!sw)
 470         return;
 471
 472
 473 }
 474
 475 /* return a string duplicated on the win32 process heap, free with HeapFree */
 476 static char* ALSA_strdup(char *s) {
 477     char *result = HeapAlloc(GetProcessHeap(), 0, strlen(s)+1);
 478     strcpy(result, s);
 479     return result;
 480 }
 481
 482 /******************************************************************
 483  *             ALSA_GetDeviceFromReg
 484  *
 485  * Returns either "default" or reads the registry so the user can
 486  * override the playback/record device used.
 487  */
 488 char *ALSA_GetDeviceFromReg(char *value)
 489 {
 490     DWORD res;
 491     DWORD type;
 492     HKEY playbackKey = 0;
 493     char *result = NULL;
 494     DWORD resultSize;
 495
 496     res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\ALSA", 0, KEY_QUERY_VALUE, &playbackKey);
 497     if (res != ERROR_SUCCESS) goto end;
 498
 499     res = RegQueryValueExA(playbackKey, value, NULL, &type, NULL, &resultSize);
 500     if (res != ERROR_SUCCESS) goto end;
 501
 502     if (type != REG_SZ) {
 503        ERR("Registry key [HKEY_LOCAL_MACHINE\\Software\\Wine\\Wine\\ALSA\\%s] must be a string\n", value);
 504        goto end;
 505     }
 506
 507     result = HeapAlloc(GetProcessHeap(), 0, resultSize);
 508     res = RegQueryValueExA(playbackKey, value, NULL, NULL, result, &resultSize);
 509
 510 end:
 511     if (!result) result = ALSA_strdup("default");
 512     if (playbackKey) RegCloseKey(playbackKey);
 513     return result;
 514 }
 515
 516 /******************************************************************
 517  *              ALSA_WaveInit
 518  *
 519  * Initialize internal structures from ALSA information
 520  */
 521 LONG ALSA_WaveInit(void)
 522 {
 523     snd_pcm_t*                  h = NULL;
 524     snd_pcm_info_t *            info;
 525     snd_pcm_hw_params_t *       hw_params;
 526     WINE_WAVEOUT*               wwo;
 527     WINE_WAVEIN*                wwi;
 528
 529     wwo = &WOutDev[0];
 530
 531     /* FIXME: use better values */
 532     wwo->device = ALSA_GetDeviceFromReg("PlaybackDevice");
 533     TRACE("using waveout device \"%s\"\n", wwo->device);
 534
 535     wwo->caps.wMid = 0x0002;
 536     wwo->caps.wPid = 0x0104;
 537     strcpy(wwo->caps.szPname, "SB16 Wave Out");
 538     wwo->caps.vDriverVersion = 0x0100;
 539     wwo->caps.dwFormats = 0x00000000;
 540     wwo->caps.dwSupport = WAVECAPS_VOLUME;
 541     strcpy(wwo->ds_desc.szDesc, "WineALSA DirectSound Driver");
 542     strcpy(wwo->ds_desc.szDrvName, "winealsa.drv");
 543     wwo->ds_guid = DSDEVID_DefaultPlayback;
 544
 545     if (!wine_dlopen("libasound.so.2", RTLD_LAZY|RTLD_GLOBAL, NULL, 0))
 546     {
 547         ERR("Error: ALSA lib needs to be loaded with flags RTLD_LAZY and RTLD_GLOBAL.\n");
 548         return -1;
 549     }
 550
 551     snd_pcm_info_alloca(&info);
 552     snd_pcm_hw_params_alloca(&hw_params);
 553
 554 #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)
 555
 556     ALSA_WodNumDevs = 0;
 557     EXIT_ON_ERROR( snd_pcm_open(&h, wwo->device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) , "open pcm" );
 558     if (!h) return -1;
 559     ALSA_WodNumDevs++;
 560
 561     EXIT_ON_ERROR( snd_pcm_info(h, info) , "pcm info" );
 562
 563     TRACE("dev=%d id=%s name=%s subdev=%d subdev_name=%s subdev_avail=%d subdev_num=%d stream=%s subclass=%s \n",
 564        snd_pcm_info_get_device(info),
 565        snd_pcm_info_get_id(info),
 566        snd_pcm_info_get_name(info),
 567        snd_pcm_info_get_subdevice(info),
 568        snd_pcm_info_get_subdevice_name(info),
 569        snd_pcm_info_get_subdevices_avail(info),
 570        snd_pcm_info_get_subdevices_count(info),
 571        snd_pcm_stream_name(snd_pcm_info_get_stream(info)),
 572        (snd_pcm_info_get_subclass(info) == SND_PCM_SUBCLASS_GENERIC_MIX ? "GENERIC MIX": "MULTI MIX"));
 573
 574     EXIT_ON_ERROR( snd_pcm_hw_params_any(h, hw_params) , "pcm hw params" );
 575 #undef EXIT_ON_ERROR
 576
 577     if (TRACE_ON(wave))
 578         ALSA_TraceParameters(hw_params, NULL, TRUE);
 579
 580     {
 581         snd_pcm_format_mask_t *     fmask;
 582         int ratemin = snd_pcm_hw_params_get_rate_min(hw_params, 0);
 583         int ratemax = snd_pcm_hw_params_get_rate_max(hw_params, 0);
 584         int chmin = snd_pcm_hw_params_get_channels_min(hw_params); \
 585         int chmax = snd_pcm_hw_params_get_channels_max(hw_params); \
 586
 587         snd_pcm_format_mask_alloca(&fmask);
 588         snd_pcm_hw_params_get_format_mask(hw_params, fmask);
 589
 590 #define X(r,v) \
 591        if ( (r) >= ratemin && ( (r) <= ratemax || ratemax == -1) ) \
 592        { \
 593           if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_U8)) \
 594           { \
 595               if (chmin <= 1 && 1 <= chmax) \
 596                   wwo->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
 597               if (chmin <= 2 && 2 <= chmax) \
 598                   wwo->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
 599           } \
 600           if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_S16_LE)) \
 601           { \
 602               if (chmin <= 1 && 1 <= chmax) \
 603                   wwo->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
 604               if (chmin <= 2 && 2 <= chmax) \
 605                   wwo->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
 606           } \
 607        }
 608        X(11025,1);
 609        X(22050,2);
 610        X(44100,4);
 611 #undef X
 612     }
 613
 614     if ( snd_pcm_hw_params_get_channels_min(hw_params) > 1) FIXME("-\n");
 615     wwo->caps.wChannels = (snd_pcm_hw_params_get_channels_max(hw_params) >= 2) ? 2 : 1;
 616     if (snd_pcm_hw_params_get_channels_min(hw_params) <= 2 && 2 <= snd_pcm_hw_params_get_channels_max(hw_params))
 617         wwo->caps.dwSupport |= WAVECAPS_LRVOLUME;
 618
 619     /* FIXME: always true ? */
 620     wwo->caps.dwSupport |= WAVECAPS_SAMPLEACCURATE;
 621
 622     {
 623         snd_pcm_access_mask_t *     acmask;
 624         snd_pcm_access_mask_alloca(&acmask);
 625         snd_pcm_hw_params_get_access_mask(hw_params, acmask);
 626
 627         /* FIXME: NONITERLEAVED and COMPLEX are not supported right now */
 628         if ( snd_pcm_access_mask_test( acmask, SND_PCM_ACCESS_MMAP_INTERLEAVED ) )
 629             wwo->caps.dwSupport |= WAVECAPS_DIRECTSOUND;
 630     }
 631
 632     TRACE("Configured with dwFmts=%08lx dwSupport=%08lx\n",
 633           wwo->caps.dwFormats, wwo->caps.dwSupport);
 634
 635     snd_pcm_close(h);
 636
 637     ALSA_InitializeVolumeCtl(wwo);
 638
 639     wwi = &WInDev[0];
 640
 641     /* FIXME: use better values */
 642     wwi->device = ALSA_GetDeviceFromReg("RecordDevice");
 643     TRACE("using wavein device \"%s\"\n", wwi->device);
 644
 645     wwi->caps.wMid = 0x0002;
 646     wwi->caps.wPid = 0x0104;
 647     strcpy(wwi->caps.szPname, "SB16 Wave In");
 648     wwi->caps.vDriverVersion = 0x0100;
 649     wwi->caps.dwFormats = 0x00000000;
 650     wwi->caps.dwSupport = WAVECAPS_VOLUME;
 651     strcpy(wwi->ds_desc.szDesc, "WineALSA DirectSound Driver");
 652     strcpy(wwi->ds_desc.szDrvName, "winealsa.drv");
 653     wwi->ds_guid = DSDEVID_DefaultPlayback;
 654
 655     snd_pcm_info_alloca(&info);
 656     snd_pcm_hw_params_alloca(&hw_params);
 657
 658 #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)
 659
 660     ALSA_WidNumDevs = 0;
 661     EXIT_ON_ERROR( snd_pcm_open(&h, wwi->device, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK) , "open pcm" );
 662     if (!h) return -1;
 663     ALSA_WidNumDevs++;
 664
 665     EXIT_ON_ERROR( snd_pcm_info(h, info) , "pcm info" );
 666
 667     TRACE("dev=%d id=%s name=%s subdev=%d subdev_name=%s subdev_avail=%d subdev_num=%d stream=%s subclass=%s \n",
 668        snd_pcm_info_get_device(info),
 669        snd_pcm_info_get_id(info),
 670        snd_pcm_info_get_name(info),
 671        snd_pcm_info_get_subdevice(info),
 672        snd_pcm_info_get_subdevice_name(info),
 673        snd_pcm_info_get_subdevices_avail(info),
 674        snd_pcm_info_get_subdevices_count(info),
 675        snd_pcm_stream_name(snd_pcm_info_get_stream(info)),
 676        (snd_pcm_info_get_subclass(info) == SND_PCM_SUBCLASS_GENERIC_MIX ? "GENERIC MIX": "MULTI MIX"));
 677
 678     EXIT_ON_ERROR( snd_pcm_hw_params_any(h, hw_params) , "pcm hw params" );
 679 #undef EXIT_ON_ERROR
 680
 681     if (TRACE_ON(wave))
 682         ALSA_TraceParameters(hw_params, NULL, TRUE);
 683
 684     {
 685         snd_pcm_format_mask_t *     fmask;
 686         int ratemin = snd_pcm_hw_params_get_rate_min(hw_params, 0);
 687         int ratemax = snd_pcm_hw_params_get_rate_max(hw_params, 0);
 688         int chmin = snd_pcm_hw_params_get_channels_min(hw_params); \
 689         int chmax = snd_pcm_hw_params_get_channels_max(hw_params); \
 690
 691         snd_pcm_format_mask_alloca(&fmask);
 692         snd_pcm_hw_params_get_format_mask(hw_params, fmask);
 693
 694 #define X(r,v) \
 695        if ( (r) >= ratemin && ( (r) <= ratemax || ratemax == -1) ) \
 696        { \
 697           if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_U8)) \
 698           { \
 699               if (chmin <= 1 && 1 <= chmax) \
 700                   wwi->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
 701               if (chmin <= 2 && 2 <= chmax) \
 702                   wwi->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
 703           } \
 704           if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_S16_LE)) \
 705           { \
 706               if (chmin <= 1 && 1 <= chmax) \
 707                   wwi->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
 708               if (chmin <= 2 && 2 <= chmax) \
 709                   wwi->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
 710           } \
 711        }
 712        X(11025,1);
 713        X(22050,2);
 714        X(44100,4);
 715 #undef X
 716     }
 717
 718     if ( snd_pcm_hw_params_get_channels_min(hw_params) > 1) FIXME("-\n");
 719     wwi->caps.wChannels = (snd_pcm_hw_params_get_channels_max(hw_params) >= 2) ? 2 : 1;
 720     if (snd_pcm_hw_params_get_channels_min(hw_params) <= 2 && 2 <= snd_pcm_hw_params_get_channels_max(hw_params))
 721         wwi->caps.dwSupport |= WAVECAPS_LRVOLUME;
 722
 723     /* FIXME: always true ? */
 724     wwi->caps.dwSupport |= WAVECAPS_SAMPLEACCURATE;
 725
 726     {
 727         snd_pcm_access_mask_t *     acmask;
 728         snd_pcm_access_mask_alloca(&acmask);
 729         snd_pcm_hw_params_get_access_mask(hw_params, acmask);
 730
 731         /* FIXME: NONITERLEAVED and COMPLEX are not supported right now */
 732         if ( snd_pcm_access_mask_test( acmask, SND_PCM_ACCESS_MMAP_INTERLEAVED ) )
 733             wwi->caps.dwSupport |= WAVECAPS_DIRECTSOUND;
 734     }
 735
 736     TRACE("Configured with dwFmts=%08lx dwSupport=%08lx\n",
 737           wwi->caps.dwFormats, wwi->caps.dwSupport);
 738
 739     snd_pcm_close(h);
 740
 741     return 0;
 742 }
 743
 744 /******************************************************************
 745  *              ALSA_InitRingMessage
 746  *
 747  * Initialize the ring of messages for passing between driver's caller and playback/record
 748  * thread
 749  */
 750 static int ALSA_InitRingMessage(ALSA_MSG_RING* omr)
 751 {
 752     omr->msg_toget = 0;
 753     omr->msg_tosave = 0;
 754 #ifdef USE_PIPE_SYNC
 755     if (pipe(omr->msg_pipe) < 0) {
 756         omr->msg_pipe[0] = -1;
 757         omr->msg_pipe[1] = -1;
 758         ERR("could not create pipe, error=%s\n", strerror(errno));
 759     }
 760 #else
 761     omr->msg_event = CreateEventA(NULL, FALSE, FALSE, NULL);
 762 #endif
 763     omr->ring_buffer_size = ALSA_RING_BUFFER_INCREMENT;
 764     omr->messages = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,omr->ring_buffer_size * sizeof(ALSA_MSG));
 765
 766     InitializeCriticalSection(&omr->msg_crst);
 767     return 0;
 768 }
 769
 770 /******************************************************************
 771  *              ALSA_DestroyRingMessage
 772  *
 773  */
 774 static int ALSA_DestroyRingMessage(ALSA_MSG_RING* omr)
 775 {
 776 #ifdef USE_PIPE_SYNC
 777     close(omr->msg_pipe[0]);
 778     close(omr->msg_pipe[1]);
 779 #else
 780     CloseHandle(omr->msg_event);
 781 #endif
 782     HeapFree(GetProcessHeap(),0,omr->messages);
 783     DeleteCriticalSection(&omr->msg_crst);
 784     return 0;
 785 }
 786
 787 /******************************************************************
 788  *              ALSA_AddRingMessage
 789  *
 790  * Inserts a new message into the ring (should be called from DriverProc derivated routines)
 791  */
 792 static int ALSA_AddRingMessage(ALSA_MSG_RING* omr, enum win_wm_message msg, DWORD param, BOOL wait)
 793 {
 794     HANDLE      hEvent = INVALID_HANDLE_VALUE;
 795
 796     EnterCriticalSection(&omr->msg_crst);
 797     if ((omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size)))
 798     {
 799         int old_ring_buffer_size = omr->ring_buffer_size;
 800         omr->ring_buffer_size += ALSA_RING_BUFFER_INCREMENT;
 801         TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
 802         omr->messages = HeapReAlloc(GetProcessHeap(),0,omr->messages, omr->ring_buffer_size * sizeof(ALSA_MSG));
 803         /* Now we need to rearrange the ring buffer so that the new
 804            buffers just allocated are in between omr->msg_tosave and
 805            omr->msg_toget.
 806         */
 807         if (omr->msg_tosave < omr->msg_toget)
 808         {
 809             memmove(&(omr->messages[omr->msg_toget + ALSA_RING_BUFFER_INCREMENT]),
 810                     &(omr->messages[omr->msg_toget]),
 811                     sizeof(ALSA_MSG)*(old_ring_buffer_size - omr->msg_toget)
 812                     );
 813             omr->msg_toget += ALSA_RING_BUFFER_INCREMENT;
 814         }
 815     }
 816     if (wait)
 817     {
 818         hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
 819         if (hEvent == INVALID_HANDLE_VALUE)
 820         {
 821             ERR("can't create event !?\n");
 822             LeaveCriticalSection(&omr->msg_crst);
 823             return 0;
 824         }
 825         if (omr->msg_toget != omr->msg_tosave && omr->messages[omr->msg_toget].msg != WINE_WM_HEADER)
 826             FIXME("two fast messages in the queue!!!!\n");
 827
 828         /* fast messages have to be added at the start of the queue */
 829         omr->msg_toget = (omr->msg_toget + omr->ring_buffer_size - 1) % omr->ring_buffer_size;
 830
 831         omr->messages[omr->msg_toget].msg = msg;
 832         omr->messages[omr->msg_toget].param = param;
 833         omr->messages[omr->msg_toget].hEvent = hEvent;
 834     }
 835     else
 836     {
 837         omr->messages[omr->msg_tosave].msg = msg;
 838         omr->messages[omr->msg_tosave].param = param;
 839         omr->messages[omr->msg_tosave].hEvent = INVALID_HANDLE_VALUE;
 840         omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
 841     }
 842     LeaveCriticalSection(&omr->msg_crst);
 843     /* signal a new message */
 844     SIGNAL_OMR(omr);
 845     if (wait)
 846     {
 847         /* wait for playback/record thread to have processed the message */
 848         WaitForSingleObject(hEvent, INFINITE);
 849         CloseHandle(hEvent);
 850     }
 851     return 1;
 852 }
 853
 854 /******************************************************************
 855  *              ALSA_RetrieveRingMessage
 856  *
 857  * Get a message from the ring. Should be called by the playback/record thread.
 858  */
 859 static int ALSA_RetrieveRingMessage(ALSA_MSG_RING* omr,
 860                                    enum win_wm_message *msg, DWORD *param, HANDLE *hEvent)
 861 {
 862     EnterCriticalSection(&omr->msg_crst);
 863
 864     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 865     {
 866         LeaveCriticalSection(&omr->msg_crst);
 867         return 0;
 868     }
 869
 870     *msg = omr->messages[omr->msg_toget].msg;
 871     omr->messages[omr->msg_toget].msg = 0;
 872     *param = omr->messages[omr->msg_toget].param;
 873     *hEvent = omr->messages[omr->msg_toget].hEvent;
 874     omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
 875     CLEAR_OMR(omr);
 876     LeaveCriticalSection(&omr->msg_crst);
 877     return 1;
 878 }
 879
 880 /******************************************************************
 881  *              ALSA_PeekRingMessage
 882  *
 883  * Peek at a message from the ring but do not remove it.
 884  * Should be called by the playback/record thread.
 885  */
 886 static int ALSA_PeekRingMessage(ALSA_MSG_RING* omr,
 887                                enum win_wm_message *msg,
 888                                DWORD *param, HANDLE *hEvent)
 889 {
 890     EnterCriticalSection(&omr->msg_crst);
 891
 892     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 893     {
 894         LeaveCriticalSection(&omr->msg_crst);
 895         return 0;
 896     }
 897
 898     *msg = omr->messages[omr->msg_toget].msg;
 899     *param = omr->messages[omr->msg_toget].param;
 900     *hEvent = omr->messages[omr->msg_toget].hEvent;
 901     LeaveCriticalSection(&omr->msg_crst);
 902     return 1;
 903 }
 904
 905 /*======================================================================*
 906  *                  Low level WAVE OUT implementation                   *
 907  *======================================================================*/
 908
 909 /**************************************************************************
 910  *                      wodNotifyClient                 [internal]
 911  */
 912 static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
 913 {
 914     TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
 915
 916     switch (wMsg) {
 917     case WOM_OPEN:
 918     case WOM_CLOSE:
 919     case WOM_DONE:
 920         if (wwo->wFlags != DCB_NULL &&
 921             !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, (HDRVR)wwo->waveDesc.hWave,
 922                             wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
 923             WARN("can't notify client !\n");
 924             return MMSYSERR_ERROR;
 925         }
 926         break;
 927     default:
 928         FIXME("Unknown callback message %u\n", wMsg);
 929         return MMSYSERR_INVALPARAM;
 930     }
 931     return MMSYSERR_NOERROR;
 932 }
 933
 934 /**************************************************************************
 935  *                              wodUpdatePlayedTotal    [internal]
 936  *
 937  */
 938 static BOOL wodUpdatePlayedTotal(WINE_WAVEOUT* wwo, snd_pcm_status_t* ps)
 939 {
 940    return TRUE;
 941 }
 942
 943 /**************************************************************************
 944  *                              wodPlayer_BeginWaveHdr          [internal]
 945  *
 946  * Makes the specified lpWaveHdr the currently playing wave header.
 947  * If the specified wave header is a begin loop and we're not already in
 948  * a loop, setup the loop.
 949  */
 950 static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
 951 {
 952     wwo->lpPlayPtr = lpWaveHdr;
 953
 954     if (!lpWaveHdr) return;
 955
 956     wwo->lpPlayPtr->reserved = 0;
 957
 958     if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
 959         if (wwo->lpLoopPtr) {
 960             WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
 961         } else {
 962             TRACE("Starting loop (%ldx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
 963             wwo->lpLoopPtr = lpWaveHdr;
 964             /* Windows does not touch WAVEHDR.dwLoops,
 965              * so we need to make an internal copy */
 966             wwo->dwLoops = lpWaveHdr->dwLoops;
 967         }
 968     }
 969 }
 970
 971 /**************************************************************************
 972  *                              wodPlayer_PlayPtrNext           [internal]
 973  *
 974  * Advance the play pointer to the next waveheader, looping if required.
 975  */
 976 static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEOUT* wwo)
 977 {
 978     LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
 979
 980     if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
 981         /* We're at the end of a loop, loop if required */
 982         if (--wwo->dwLoops > 0) {
 983             wwo->lpPlayPtr = wwo->lpLoopPtr;
 984             wwo->lpPlayPtr->reserved = 0;
 985         } else {
 986             /* Handle overlapping loops correctly */
 987             if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
 988                 FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
 989                 /* shall we consider the END flag for the closing loop or for
 990                  * the opening one or for both ???
 991                  * code assumes for closing loop only
 992                  */
 993             } else {
 994                 lpWaveHdr = lpWaveHdr->lpNext;
 995             }
 996             wwo->lpLoopPtr = NULL;
 997             wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
 998         }
 999     } else {
1000         /* We're not in a loop.  Advance to the next wave header */
1001         wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
1002     }
1003
1004     return lpWaveHdr;
1005 }
1006
1007 /**************************************************************************
1008  *                           wodPlayer_DSPWait                  [internal]
1009  * Returns the number of milliseconds to wait for the DSP buffer to play a
1010  * period
1011  */
1012 static DWORD wodPlayer_DSPWait(const WINE_WAVEOUT *wwo)
1013 {
1014     /* time for one period to be played */
1015     return snd_pcm_hw_params_get_period_time(wwo->hw_params, 0) / 1000;
1016 }
1017
1018 /**************************************************************************
1019  *                           wodPllayer_NotifyWait               [internal]
1020  * Returns the number of milliseconds to wait before attempting to notify
1021  * completion of the specified wavehdr.
1022  * This is based on the number of bytes remaining to be written in the
1023  * wave.
1024  */
1025 static DWORD wodPlayer_NotifyWait(const WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
1026 {
1027     DWORD dwMillis;
1028
1029     dwMillis = (lpWaveHdr->dwBufferLength - lpWaveHdr->reserved) * 1000 / wwo->format.wf.nAvgBytesPerSec;
1030     if (!dwMillis) dwMillis = 1;
1031
1032     return dwMillis;
1033 }
1034
1035
1036 /**************************************************************************
1037  *                           wodPlayer_WriteMaxFrags            [internal]
1038  * Writes the maximum number of frames possible to the DSP and returns
1039  * the number of frames written.
1040  */
1041 static int wodPlayer_WriteMaxFrags(WINE_WAVEOUT* wwo, DWORD* frames)
1042 {
1043     /* Only attempt to write to free frames */
1044     LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
1045     DWORD dwLength = snd_pcm_bytes_to_frames(wwo->p_handle, lpWaveHdr->dwBufferLength - lpWaveHdr->reserved);
1046     int toWrite = min(dwLength, *frames);
1047     int written;
1048
1049     TRACE("Writing wavehdr %p.%lu[%lu]\n", lpWaveHdr, lpWaveHdr->reserved, lpWaveHdr->dwBufferLength);
1050
1051     written = (wwo->write)(wwo->p_handle, lpWaveHdr->lpData + lpWaveHdr->reserved, toWrite);
1052     if ( written < 0)
1053     {
1054         /* XRUN occurred. let's try to recover */
1055         ALSA_XRUNRecovery(wwo, written);
1056         written = (wwo->write)(wwo->p_handle, lpWaveHdr->lpData + lpWaveHdr->reserved, toWrite);
1057     }
1058     if (written <= 0)
1059     {
1060         /* still in error */
1061         ERR("Error in writing wavehdr. Reason: %s\n", snd_strerror(written));
1062         return written;
1063     }
1064
1065     lpWaveHdr->reserved += snd_pcm_frames_to_bytes(wwo->p_handle, written);
1066     if ( lpWaveHdr->reserved >= lpWaveHdr->dwBufferLength) {
1067         /* this will be used to check if the given wave header has been fully played or not... */
1068         lpWaveHdr->reserved = lpWaveHdr->dwBufferLength;
1069         /* If we wrote all current wavehdr, skip to the next one */
1070         wodPlayer_PlayPtrNext(wwo);
1071     }
1072     *frames -= written;
1073     wwo->dwPlayedTotal += snd_pcm_frames_to_bytes(wwo->p_handle, written);
1074
1075     return written;
1076 }
1077
1078
1079 /**************************************************************************
1080  *                              wodPlayer_NotifyCompletions     [internal]
1081  *
1082  * Notifies and remove from queue all wavehdrs which have been played to
1083  * the speaker (ie. they have cleared the ALSA buffer).  If force is true,
1084  * we notify all wavehdrs and remove them all from the queue even if they
1085  * are unplayed or part of a loop.
1086  */
1087 static DWORD wodPlayer_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
1088 {
1089     LPWAVEHDR           lpWaveHdr;
1090
1091     /* Start from lpQueuePtr and keep notifying until:
1092      * - we hit an unwritten wavehdr
1093      * - we hit the beginning of a running loop
1094      * - we hit a wavehdr which hasn't finished playing
1095      */
1096     while ((lpWaveHdr = wwo->lpQueuePtr) &&
1097            (force ||
1098             (lpWaveHdr != wwo->lpPlayPtr &&
1099              lpWaveHdr != wwo->lpLoopPtr &&
1100              lpWaveHdr->reserved == lpWaveHdr->dwBufferLength))) {
1101
1102         wwo->lpQueuePtr = lpWaveHdr->lpNext;
1103
1104         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1105         lpWaveHdr->dwFlags |= WHDR_DONE;
1106
1107         wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
1108     }
1109     return  (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != wwo->lpLoopPtr) ?
1110         wodPlayer_NotifyWait(wwo, lpWaveHdr) : INFINITE;
1111 }
1112
1113
1114 void wait_for_poll(snd_pcm_t *handle, struct pollfd *ufds, unsigned int count)
1115 {
1116     unsigned short revents;
1117
1118     if (snd_pcm_state(handle) != SND_PCM_STATE_RUNNING)
1119         return;
1120
1121     while (1) {
1122         poll(ufds, count, -1);
1123         snd_pcm_poll_descriptors_revents(handle, ufds, count, &revents);
1124
1125         if (revents & POLLERR)
1126             return;
1127
1128         /*if (revents & POLLOUT)
1129                 return 0;*/
1130     }
1131 }
1132
1133
1134 /**************************************************************************
1135  *                              wodPlayer_Reset                 [internal]
1136  *
1137  * wodPlayer helper. Resets current output stream.
1138  */
1139 static  void    wodPlayer_Reset(WINE_WAVEOUT* wwo)
1140 {
1141     enum win_wm_message msg;
1142     DWORD                       param;
1143     HANDLE                      ev;
1144     int                         err;
1145
1146     /* flush all possible output */
1147     wait_for_poll(wwo->p_handle, wwo->ufds, wwo->count);
1148
1149     /* updates current notify list */
1150     wodPlayer_NotifyCompletions(wwo, FALSE);
1151
1152     if ( (err = snd_pcm_drop(wwo->p_handle)) < 0) {
1153         FIXME("flush: %s\n", snd_strerror(err));
1154         wwo->hThread = 0;
1155         wwo->state = WINE_WS_STOPPED;
1156         ExitThread(-1);
1157     }
1158     if ( (err = snd_pcm_prepare(wwo->p_handle)) < 0 )
1159         ERR("pcm prepare failed: %s\n", snd_strerror(err));
1160
1161     /* remove any buffer */
1162     wodPlayer_NotifyCompletions(wwo, TRUE);
1163
1164     wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
1165     wwo->state = WINE_WS_STOPPED;
1166
1167     /* remove any existing message in the ring */
1168     EnterCriticalSection(&wwo->msgRing.msg_crst);
1169     /* return all pending headers in queue */
1170     while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev))
1171     {
1172         if (msg != WINE_WM_HEADER)
1173         {
1174             FIXME("shouldn't have headers left\n");
1175             SetEvent(ev);
1176             continue;
1177         }
1178         ((LPWAVEHDR)param)->dwFlags &= ~WHDR_INQUEUE;
1179         ((LPWAVEHDR)param)->dwFlags |= WHDR_DONE;
1180
1181         wodNotifyClient(wwo, WOM_DONE, param, 0);
1182     }
1183     RESET_OMR(&wwo->msgRing);
1184     LeaveCriticalSection(&wwo->msgRing.msg_crst);
1185 }
1186
1187 /**************************************************************************
1188  *                    wodPlayer_ProcessMessages                 [internal]
1189  */
1190 static void wodPlayer_ProcessMessages(WINE_WAVEOUT* wwo)
1191 {
1192     LPWAVEHDR           lpWaveHdr;
1193     enum win_wm_message msg;
1194     DWORD               param;
1195     HANDLE              ev;
1196     int                 err;
1197
1198     while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev)) {
1199      TRACE("Received %s %lx\n", wodPlayerCmdString[msg - WM_USER - 1], param);
1200
1201         switch (msg) {
1202         case WINE_WM_PAUSING:
1203             if ( snd_pcm_state(wwo->p_handle) == SND_PCM_STATE_RUNNING )
1204              {
1205                 err = snd_pcm_pause(wwo->p_handle, 1);
1206                 if ( err < 0 )
1207                     ERR("pcm_pause failed: %s\n", snd_strerror(err));
1208              }
1209             wwo->state = WINE_WS_PAUSED;
1210             SetEvent(ev);
1211             break;
1212         case WINE_WM_RESTARTING:
1213             if (wwo->state == WINE_WS_PAUSED)
1214             {
1215                 if ( snd_pcm_state(wwo->p_handle) == SND_PCM_STATE_PAUSED )
1216                  {
1217                     err = snd_pcm_pause(wwo->p_handle, 0);
1218                     if ( err < 0 )
1219                         ERR("pcm_pause failed: %s\n", snd_strerror(err));
1220                  }
1221                 wwo->state = WINE_WS_PLAYING;
1222             }
1223             SetEvent(ev);
1224             break;
1225         case WINE_WM_HEADER:
1226             lpWaveHdr = (LPWAVEHDR)param;
1227
1228             /* insert buffer at the end of queue */
1229             {
1230                 LPWAVEHDR*      wh;
1231                 for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
1232                 *wh = lpWaveHdr;
1233             }
1234             if (!wwo->lpPlayPtr)
1235                 wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
1236             if (wwo->state == WINE_WS_STOPPED)
1237                 wwo->state = WINE_WS_PLAYING;
1238             break;
1239         case WINE_WM_RESETTING:
1240             wodPlayer_Reset(wwo);
1241             SetEvent(ev);
1242             break;
1243         case WINE_WM_UPDATE:
1244             wodUpdatePlayedTotal(wwo, NULL);
1245             SetEvent(ev);
1246             break;
1247         case WINE_WM_BREAKLOOP:
1248             if (wwo->state == WINE_WS_PLAYING && wwo->lpLoopPtr != NULL) {
1249                 /* ensure exit at end of current loop */
1250                 wwo->dwLoops = 1;
1251             }
1252             SetEvent(ev);
1253             break;
1254         case WINE_WM_CLOSING:
1255             /* sanity check: this should not happen since the device must have been reset before */
1256             if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
1257             wwo->hThread = 0;
1258             wwo->state = WINE_WS_CLOSED;
1259             SetEvent(ev);
1260             ExitThread(0);
1261             /* shouldn't go here */
1262         default:
1263             FIXME("unknown message %d\n", msg);
1264             break;
1265         }
1266     }
1267 }
1268
1269 /**************************************************************************
1270  *                           wodPlayer_FeedDSP                  [internal]
1271  * Feed as much sound data as we can into the DSP and return the number of
1272  * milliseconds before it will be necessary to feed the DSP again.
1273  */
1274 static DWORD wodPlayer_FeedDSP(WINE_WAVEOUT* wwo)
1275 {
1276     DWORD               availInQ = snd_pcm_avail_update(wwo->p_handle);
1277
1278     /* no more room... no need to try to feed */
1279     while (wwo->lpPlayPtr && availInQ > 0)
1280         if ( wodPlayer_WriteMaxFrags(wwo, &availInQ) < 0 )
1281             break;
1282
1283     return wodPlayer_DSPWait(wwo);
1284 }
1285
1286 /**************************************************************************
1287  *                              wodPlayer                       [internal]
1288  */
1289 static  DWORD   CALLBACK        wodPlayer(LPVOID pmt)
1290 {
1291     WORD          uDevID = (DWORD)pmt;
1292     WINE_WAVEOUT* wwo = (WINE_WAVEOUT*)&WOutDev[uDevID];
1293     DWORD         dwNextFeedTime = INFINITE;   /* Time before DSP needs feeding */
1294     DWORD         dwNextNotifyTime = INFINITE; /* Time before next wave completion */
1295     DWORD         dwSleepTime;
1296
1297     wwo->state = WINE_WS_STOPPED;
1298     SetEvent(wwo->hStartUpEvent);
1299
1300     for (;;) {
1301         /** Wait for the shortest time before an action is required.  If there
1302          *  are no pending actions, wait forever for a command.
1303          */
1304         dwSleepTime = min(dwNextFeedTime, dwNextNotifyTime);
1305         TRACE("waiting %lums (%lu,%lu)\n", dwSleepTime, dwNextFeedTime, dwNextNotifyTime);
1306         WAIT_OMR(&wwo->msgRing, dwSleepTime);
1307         wodPlayer_ProcessMessages(wwo);
1308         if (wwo->state == WINE_WS_PLAYING) {
1309             dwNextFeedTime = wodPlayer_FeedDSP(wwo);
1310             dwNextNotifyTime = wodPlayer_NotifyCompletions(wwo, FALSE);
1311         } else {
1312             dwNextFeedTime = dwNextNotifyTime = INFINITE;
1313         }
1314     }
1315 }
1316
1317 /**************************************************************************
1318  *                      wodGetDevCaps                           [internal]
1319  */
1320 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSA lpCaps, DWORD dwSize)
1321 {
1322     TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
1323
1324     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1325
1326     if (wDevID >= MAX_WAVEOUTDRV) {
1327         TRACE("MAX_WAVOUTDRV reached !\n");
1328         return MMSYSERR_BADDEVICEID;
1329     }
1330
1331     memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1332     return MMSYSERR_NOERROR;
1333 }
1334
1335 /**************************************************************************
1336  *                              wodOpen                         [internal]
1337  */
1338 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1339 {
1340     WINE_WAVEOUT*               wwo;
1341     snd_pcm_hw_params_t *       hw_params;
1342     snd_pcm_sw_params_t *       sw_params;
1343     snd_pcm_access_t            access;
1344     snd_pcm_format_t            format;
1345     int                         rate;
1346     unsigned int                buffer_time = 500000;
1347     unsigned int                period_time = 10000;
1348     int                         buffer_size;
1349     snd_pcm_uframes_t           period_size;
1350     int                         flags;
1351     snd_pcm_t *                 pcm;
1352     int                         err;
1353
1354     snd_pcm_hw_params_alloca(&hw_params);
1355     snd_pcm_sw_params_alloca(&sw_params);
1356
1357     TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
1358     if (lpDesc == NULL) {
1359         WARN("Invalid Parameter !\n");
1360         return MMSYSERR_INVALPARAM;
1361     }
1362     if (wDevID >= MAX_WAVEOUTDRV) {
1363         TRACE("MAX_WAVOUTDRV reached !\n");
1364         return MMSYSERR_BADDEVICEID;
1365     }
1366
1367     /* only PCM format is supported so far... */
1368     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1369         lpDesc->lpFormat->nChannels == 0 ||
1370         lpDesc->lpFormat->nSamplesPerSec == 0) {
1371         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1372              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1373              lpDesc->lpFormat->nSamplesPerSec);
1374         return WAVERR_BADFORMAT;
1375     }
1376
1377     if (dwFlags & WAVE_FORMAT_QUERY) {
1378         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1379              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1380              lpDesc->lpFormat->nSamplesPerSec);
1381         return MMSYSERR_NOERROR;
1382     }
1383
1384     wwo = &WOutDev[wDevID];
1385
1386     if ((dwFlags & WAVE_DIRECTSOUND) && !(wwo->caps.dwSupport & WAVECAPS_DIRECTSOUND))
1387         /* not supported, ignore it */
1388         dwFlags &= ~WAVE_DIRECTSOUND;
1389
1390     wwo->p_handle = 0;
1391     flags = SND_PCM_NONBLOCK;
1392     if ( dwFlags & WAVE_DIRECTSOUND )
1393         flags |= SND_PCM_ASYNC;
1394
1395     if ( (err = snd_pcm_open(&pcm, wwo->device, SND_PCM_STREAM_PLAYBACK, dwFlags)) < 0)
1396     {
1397         ERR("Error open: %s\n", snd_strerror(err));
1398         return MMSYSERR_NOTENABLED;
1399     }
1400
1401     wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1402
1403     memcpy(&wwo->waveDesc, lpDesc,           sizeof(WAVEOPENDESC));
1404     memcpy(&wwo->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
1405
1406     if (wwo->format.wBitsPerSample == 0) {
1407         WARN("Resetting zeroed wBitsPerSample\n");
1408         wwo->format.wBitsPerSample = 8 *
1409             (wwo->format.wf.nAvgBytesPerSec /
1410              wwo->format.wf.nSamplesPerSec) /
1411             wwo->format.wf.nChannels;
1412     }
1413
1414     snd_pcm_hw_params_any(pcm, hw_params);
1415
1416 #define EXIT_ON_ERROR(f,e,txt) do \
1417 { \
1418     int err; \
1419     if ( (err = (f) ) < 0) \
1420     { \
1421         ERR(txt ": %s\n", snd_strerror(err)); \
1422         snd_pcm_close(pcm); \
1423         return e; \
1424     } \
1425 } while(0)
1426
1427     access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
1428     if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
1429         WARN("mmap not available. switching to standard write.\n");
1430         access = SND_PCM_ACCESS_RW_INTERLEAVED;
1431         EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
1432         wwo->write = snd_pcm_writei;
1433     }
1434     else
1435         wwo->write = snd_pcm_mmap_writei;
1436
1437     EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwo->format.wf.nChannels), MMSYSERR_INVALPARAM, "unable to set required channels");
1438
1439     format = (wwo->format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE : SND_PCM_FORMAT_U8;
1440     EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), MMSYSERR_INVALPARAM, "unable to set required format");
1441
1442     rate = snd_pcm_hw_params_set_rate_near(pcm, hw_params, wwo->format.wf.nSamplesPerSec, 0);
1443     if (rate < 0) {
1444         ERR("Rate %ld Hz not available for playback: %s\n", wwo->format.wf.nSamplesPerSec, snd_strerror(rate));
1445         snd_pcm_close(pcm);
1446         return WAVERR_BADFORMAT;
1447     }
1448     if (rate != wwo->format.wf.nSamplesPerSec) {
1449         ERR("Rate doesn't match (requested %ld Hz, got %d Hz)\n", wwo->format.wf.nSamplesPerSec, rate);
1450         snd_pcm_close(pcm);
1451         return WAVERR_BADFORMAT;
1452     }
1453
1454     EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, buffer_time, 0), MMSYSERR_INVALPARAM, "unable to set buffer time");
1455     EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm, hw_params, period_time, 0), MMSYSERR_INVALPARAM, "unable to set period time");
1456
1457     EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
1458
1459     period_size = snd_pcm_hw_params_get_period_size(hw_params, 0);
1460     buffer_size = snd_pcm_hw_params_get_buffer_size(hw_params);
1461
1462     snd_pcm_sw_params_current(pcm, sw_params);
1463     EXIT_ON_ERROR( snd_pcm_sw_params_set_start_threshold(pcm, sw_params, dwFlags & WAVE_DIRECTSOUND ? INT_MAX : 1 ), MMSYSERR_ERROR, "unable to set start threshold");
1464     EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence size");
1465     EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
1466     EXIT_ON_ERROR( snd_pcm_sw_params_set_xfer_align(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set xfer align");
1467     EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
1468     EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
1469 #undef EXIT_ON_ERROR
1470
1471     snd_pcm_prepare(pcm);
1472
1473     if (TRACE_ON(wave))
1474         ALSA_TraceParameters(hw_params, sw_params, FALSE);
1475
1476     /* now, we can save all required data for later use... */
1477     if ( wwo->hw_params )
1478         snd_pcm_hw_params_free(wwo->hw_params);
1479     snd_pcm_hw_params_malloc(&(wwo->hw_params));
1480     snd_pcm_hw_params_copy(wwo->hw_params, hw_params);
1481
1482     wwo->dwBufferSize = buffer_size;
1483     wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
1484     wwo->p_handle = pcm;
1485
1486     ALSA_InitRingMessage(&wwo->msgRing);
1487
1488     wwo->count = snd_pcm_poll_descriptors_count (wwo->p_handle);
1489     if (wwo->count <= 0) {
1490         ERR("Invalid poll descriptors count\n");
1491         return MMSYSERR_ERROR;
1492     }
1493
1494     wwo->ufds = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(struct pollfd) * wwo->count);
1495     if (wwo->ufds == NULL) {
1496         ERR("No enough memory\n");
1497         return MMSYSERR_NOMEM;
1498     }
1499     if ((err = snd_pcm_poll_descriptors(wwo->p_handle, wwo->ufds, wwo->count)) < 0) {
1500         ERR("Unable to obtain poll descriptors for playback: %s\n", snd_strerror(err));
1501         return MMSYSERR_ERROR;
1502     }
1503
1504     if (!(dwFlags & WAVE_DIRECTSOUND)) {
1505         wwo->hStartUpEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1506         wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD)wDevID, 0, &(wwo->dwThreadID));
1507         WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
1508         CloseHandle(wwo->hStartUpEvent);
1509     } else {
1510         wwo->hThread = INVALID_HANDLE_VALUE;
1511         wwo->dwThreadID = 0;
1512     }
1513     wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
1514
1515     TRACE("handle=%08lx \n", (DWORD)wwo->p_handle);
1516 /*    if (wwo->dwFragmentSize % wwo->format.wf.nBlockAlign)
1517         ERR("Fragment doesn't contain an integral number of data blocks\n");
1518 */
1519     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n",
1520           wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec,
1521           wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1522           wwo->format.wf.nBlockAlign);
1523
1524     return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
1525 }
1526
1527
1528 /**************************************************************************
1529  *                              wodClose                        [internal]
1530  */
1531 static DWORD wodClose(WORD wDevID)
1532 {
1533     DWORD               ret = MMSYSERR_NOERROR;
1534     WINE_WAVEOUT*       wwo;
1535
1536     TRACE("(%u);\n", wDevID);
1537
1538     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1539         WARN("bad device ID !\n");
1540         return MMSYSERR_BADDEVICEID;
1541     }
1542
1543     wwo = &WOutDev[wDevID];
1544     if (wwo->lpQueuePtr) {
1545         WARN("buffers still playing !\n");
1546         ret = WAVERR_STILLPLAYING;
1547     } else {
1548         if (wwo->hThread != INVALID_HANDLE_VALUE) {
1549             ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_CLOSING, 0, TRUE);
1550         }
1551         ALSA_DestroyRingMessage(&wwo->msgRing);
1552
1553         snd_pcm_hw_params_free(wwo->hw_params);
1554         wwo->hw_params = NULL;
1555
1556         snd_pcm_close(wwo->p_handle);
1557         wwo->p_handle = NULL;
1558
1559         ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
1560     }
1561
1562     HeapFree(GetProcessHeap(), 0, wwo->ufds);
1563     return ret;
1564 }
1565
1566
1567 /**************************************************************************
1568  *                              wodWrite                        [internal]
1569  *
1570  */
1571 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1572 {
1573     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1574
1575     /* first, do the sanity checks... */
1576     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1577         WARN("bad dev ID !\n");
1578         return MMSYSERR_BADDEVICEID;
1579     }
1580
1581     if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
1582         return WAVERR_UNPREPARED;
1583
1584     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1585         return WAVERR_STILLPLAYING;
1586
1587     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1588     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1589     lpWaveHdr->lpNext = 0;
1590
1591     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
1592
1593     return MMSYSERR_NOERROR;
1594 }
1595
1596 /**************************************************************************
1597  *                              wodPrepare                      [internal]
1598  */
1599 static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1600 {
1601     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1602
1603     if (wDevID >= MAX_WAVEOUTDRV) {
1604         WARN("bad device ID !\n");
1605         return MMSYSERR_BADDEVICEID;
1606     }
1607
1608     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1609         return WAVERR_STILLPLAYING;
1610
1611     lpWaveHdr->dwFlags |= WHDR_PREPARED;
1612     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1613     return MMSYSERR_NOERROR;
1614 }
1615
1616 /**************************************************************************
1617  *                              wodUnprepare                    [internal]
1618  */
1619 static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1620 {
1621     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1622
1623     if (wDevID >= MAX_WAVEOUTDRV) {
1624         WARN("bad device ID !\n");
1625         return MMSYSERR_BADDEVICEID;
1626     }
1627
1628     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1629         return WAVERR_STILLPLAYING;
1630
1631     lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
1632     lpWaveHdr->dwFlags |= WHDR_DONE;
1633
1634     return MMSYSERR_NOERROR;
1635 }
1636
1637 /**************************************************************************
1638  *                      wodPause                                [internal]
1639  */
1640 static DWORD wodPause(WORD wDevID)
1641 {
1642     TRACE("(%u);!\n", wDevID);
1643
1644     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1645         WARN("bad device ID !\n");
1646         return MMSYSERR_BADDEVICEID;
1647     }
1648
1649     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_PAUSING, 0, TRUE);
1650
1651     return MMSYSERR_NOERROR;
1652 }
1653
1654 /**************************************************************************
1655  *                      wodRestart                              [internal]
1656  */
1657 static DWORD wodRestart(WORD wDevID)
1658 {
1659     TRACE("(%u);\n", wDevID);
1660
1661     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1662         WARN("bad device ID !\n");
1663         return MMSYSERR_BADDEVICEID;
1664     }
1665
1666     if (WOutDev[wDevID].state == WINE_WS_PAUSED) {
1667         ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESTARTING, 0, TRUE);
1668     }
1669
1670     /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
1671     /* FIXME: Myst crashes with this ... hmm -MM
1672        return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
1673     */
1674
1675     return MMSYSERR_NOERROR;
1676 }
1677
1678 /**************************************************************************
1679  *                      wodReset                                [internal]
1680  */
1681 static DWORD wodReset(WORD wDevID)
1682 {
1683     TRACE("(%u);\n", wDevID);
1684
1685     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1686         WARN("bad device ID !\n");
1687         return MMSYSERR_BADDEVICEID;
1688     }
1689
1690     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
1691
1692     return MMSYSERR_NOERROR;
1693 }
1694
1695 /**************************************************************************
1696  *                              wodGetPosition                  [internal]
1697  */
1698 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1699 {
1700     int                 time;
1701     DWORD               val;
1702     WINE_WAVEOUT*       wwo;
1703
1704     TRACE("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
1705
1706     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1707         WARN("bad device ID !\n");
1708         return MMSYSERR_BADDEVICEID;
1709     }
1710
1711     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1712
1713     wwo = &WOutDev[wDevID];
1714     ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_UPDATE, 0, TRUE);
1715     val = wwo->dwPlayedTotal;
1716
1717     TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%lu nChannels=%u nAvgBytesPerSec=%lu\n",
1718           lpTime->wType, wwo->format.wBitsPerSample,
1719           wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1720           wwo->format.wf.nAvgBytesPerSec);
1721     TRACE("dwPlayedTotal=%lu\n", val);
1722
1723     switch (lpTime->wType) {
1724     case TIME_BYTES:
1725         lpTime->u.cb = val;
1726         TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
1727         break;
1728     case TIME_SAMPLES:
1729         lpTime->u.sample = val * 8 / wwo->format.wBitsPerSample /wwo->format.wf.nChannels;
1730         TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
1731         break;
1732     case TIME_SMPTE:
1733         time = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
1734         lpTime->u.smpte.hour = time / (60 * 60 * 1000);
1735         time -= lpTime->u.smpte.hour * (60 * 60 * 1000);
1736         lpTime->u.smpte.min = time / (60 * 1000);
1737         time -= lpTime->u.smpte.min * (60 * 1000);
1738         lpTime->u.smpte.sec = time / 1000;
1739         time -= lpTime->u.smpte.sec * 1000;
1740         lpTime->u.smpte.frame = time * 30 / 1000;
1741         lpTime->u.smpte.fps = 30;
1742         TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
1743               lpTime->u.smpte.hour, lpTime->u.smpte.min,
1744               lpTime->u.smpte.sec, lpTime->u.smpte.frame);
1745         break;
1746     default:
1747         FIXME("Format %d not supported ! use TIME_MS !\n", lpTime->wType);
1748         lpTime->wType = TIME_MS;
1749     case TIME_MS:
1750         lpTime->u.ms = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
1751         TRACE("TIME_MS=%lu\n", lpTime->u.ms);
1752         break;
1753     }
1754     return MMSYSERR_NOERROR;
1755 }
1756
1757 /**************************************************************************
1758  *                              wodBreakLoop                    [internal]
1759  */
1760 static DWORD wodBreakLoop(WORD wDevID)
1761 {
1762     TRACE("(%u);\n", wDevID);
1763
1764     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1765         WARN("bad device ID !\n");
1766         return MMSYSERR_BADDEVICEID;
1767     }
1768     ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_BREAKLOOP, 0, TRUE);
1769     return MMSYSERR_NOERROR;
1770 }
1771
1772 /**************************************************************************
1773  *                              wodGetVolume                    [internal]
1774  */
1775 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1776 {
1777     WORD               left, right;
1778     WINE_WAVEOUT*      wwo;
1779     int                count;
1780     long               min, max;
1781
1782     TRACE("(%u, %p);\n", wDevID, lpdwVol);
1783     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1784         WARN("bad device ID !\n");
1785         return MMSYSERR_BADDEVICEID;
1786     }
1787     wwo = &WOutDev[wDevID];
1788     count = snd_ctl_elem_info_get_count(wwo->playback_einfo);
1789     min = snd_ctl_elem_info_get_min(wwo->playback_einfo);
1790     max = snd_ctl_elem_info_get_max(wwo->playback_einfo);
1791
1792 #define VOLUME_ALSA_TO_WIN(x) (((x)-min) * 65536 /(max-min))
1793     if (lpdwVol == NULL)
1794         return MMSYSERR_NOTENABLED;
1795
1796     switch (count)
1797     {
1798         case 2:
1799             left = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 0));
1800             right = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 1));
1801             break;
1802         case 1:
1803             left = right = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 0));
1804             break;
1805         default:
1806             WARN("%d channels mixer not supported\n", count);
1807             return MMSYSERR_NOERROR;
1808      }
1809 #undef VOLUME_ALSA_TO_WIN
1810
1811     TRACE("left=%d right=%d !\n", left, right);
1812     *lpdwVol = MAKELONG( left, right );
1813     return MMSYSERR_NOERROR;
1814 }
1815
1816 /**************************************************************************
1817  *                              wodSetVolume                    [internal]
1818  */
1819 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1820 {
1821     WORD               left, right;
1822     WINE_WAVEOUT*      wwo;
1823     int                count, err;
1824     long               min, max;
1825
1826     TRACE("(%u, %08lX);\n", wDevID, dwParam);
1827     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1828         WARN("bad device ID !\n");
1829         return MMSYSERR_BADDEVICEID;
1830     }
1831     wwo = &WOutDev[wDevID];
1832     count=snd_ctl_elem_info_get_count(wwo->playback_einfo);
1833     min = snd_ctl_elem_info_get_min(wwo->playback_einfo);
1834     max = snd_ctl_elem_info_get_max(wwo->playback_einfo);
1835
1836     left  = LOWORD(dwParam);
1837     right = HIWORD(dwParam);
1838
1839 #define VOLUME_WIN_TO_ALSA(x) ( (((x) * (max-min)) / 65536) + min )
1840     switch (count)
1841     {
1842         case 2:
1843             snd_ctl_elem_value_set_integer(wwo->playback_evalue, 0, VOLUME_WIN_TO_ALSA(left));
1844             snd_ctl_elem_value_set_integer(wwo->playback_evalue, 1, VOLUME_WIN_TO_ALSA(right));
1845             break;
1846         case 1:
1847             snd_ctl_elem_value_set_integer(wwo->playback_evalue, 0, VOLUME_WIN_TO_ALSA(left));
1848             break;
1849         default:
1850             WARN("%d channels mixer not supported\n", count);
1851      }
1852 #undef VOLUME_WIN_TO_ALSA
1853     if ( (err = snd_ctl_elem_write(wwo->ctl, wwo->playback_evalue)) < 0)
1854     {
1855         ERR("error writing snd_ctl_elem_value: %s\n", snd_strerror(err));
1856     }
1857     return MMSYSERR_NOERROR;
1858 }
1859
1860 /**************************************************************************
1861  *                              wodGetNumDevs                   [internal]
1862  */
1863 static  DWORD   wodGetNumDevs(void)
1864 {
1865     return ALSA_WodNumDevs;
1866 }
1867
1868 /**************************************************************************
1869  *                              wodDevInterfaceSize             [internal]
1870  */
1871 static DWORD wodDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
1872 {
1873     TRACE("(%u, %p)\n", wDevID, dwParam1);
1874
1875     *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].device, -1,
1876                                     NULL, 0 ) * sizeof(WCHAR);
1877     return MMSYSERR_NOERROR;
1878 }
1879
1880 /**************************************************************************
1881  *                              wodDevInterface                 [internal]
1882  */
1883 static DWORD wodDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
1884 {
1885     if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].device, -1,
1886                                         NULL, 0 ) * sizeof(WCHAR))
1887     {
1888         MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].device, -1,
1889                             dwParam1, dwParam2 / sizeof(WCHAR));
1890         return MMSYSERR_NOERROR;
1891     }
1892     return MMSYSERR_INVALPARAM;
1893 }
1894
1895 /**************************************************************************
1896  *                              wodMessage (WINEALSA.@)
1897  */
1898 DWORD WINAPI ALSA_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1899                              DWORD dwParam1, DWORD dwParam2)
1900 {
1901     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
1902           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1903
1904     switch (wMsg) {
1905     case DRVM_INIT:
1906     case DRVM_EXIT:
1907     case DRVM_ENABLE:
1908     case DRVM_DISABLE:
1909         /* FIXME: Pretend this is supported */
1910         return 0;
1911     case WODM_OPEN:             return wodOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,      dwParam2);
1912     case WODM_CLOSE:            return wodClose         (wDevID);
1913     case WODM_GETDEVCAPS:       return wodGetDevCaps    (wDevID, (LPWAVEOUTCAPSA)dwParam1,      dwParam2);
1914     case WODM_GETNUMDEVS:       return wodGetNumDevs    ();
1915     case WODM_GETPITCH:         return MMSYSERR_NOTSUPPORTED;
1916     case WODM_SETPITCH:         return MMSYSERR_NOTSUPPORTED;
1917     case WODM_GETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1918     case WODM_SETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1919     case WODM_WRITE:            return wodWrite         (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1920     case WODM_PAUSE:            return wodPause         (wDevID);
1921     case WODM_GETPOS:           return wodGetPosition   (wDevID, (LPMMTIME)dwParam1,            dwParam2);
1922     case WODM_BREAKLOOP:        return wodBreakLoop     (wDevID);
1923     case WODM_PREPARE:          return wodPrepare       (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1924     case WODM_UNPREPARE:        return wodUnprepare     (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1925     case WODM_GETVOLUME:        return wodGetVolume     (wDevID, (LPDWORD)dwParam1);
1926     case WODM_SETVOLUME:        return wodSetVolume     (wDevID, dwParam1);
1927     case WODM_RESTART:          return wodRestart       (wDevID);
1928     case WODM_RESET:            return wodReset         (wDevID);
1929     case DRV_QUERYDEVICEINTERFACESIZE: return wodDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
1930     case DRV_QUERYDEVICEINTERFACE:     return wodDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
1931     case DRV_QUERYDSOUNDIFACE:  return wodDsCreate      (wDevID, (PIDSDRIVER*)dwParam1);
1932     case DRV_QUERYDSOUNDDESC:   return wodDsDesc        (wDevID, (PDSDRIVERDESC)dwParam1);
1933     case DRV_QUERYDSOUNDGUID:   return wodDsGuid        (wDevID, (LPGUID)dwParam1);
1934
1935     default:
1936         FIXME("unknown message %d!\n", wMsg);
1937     }
1938     return MMSYSERR_NOTSUPPORTED;
1939 }
1940
1941 /*======================================================================*
1942  *                  Low level DSOUND implementation                     *
1943  *======================================================================*/
1944
1945 typedef struct IDsDriverImpl IDsDriverImpl;
1946 typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
1947
1948 struct IDsDriverImpl
1949 {
1950     /* IUnknown fields */
1951     ICOM_VFIELD(IDsDriver);
1952     DWORD               ref;
1953     /* IDsDriverImpl fields */
1954     UINT                wDevID;
1955     IDsDriverBufferImpl*primary;
1956 };
1957
1958 struct IDsDriverBufferImpl
1959 {
1960     /* IUnknown fields */
1961     ICOM_VFIELD(IDsDriverBuffer);
1962     DWORD                     ref;
1963     /* IDsDriverBufferImpl fields */
1964     IDsDriverImpl*            drv;
1965
1966     CRITICAL_SECTION          mmap_crst;
1967     LPVOID                    mmap_buffer;
1968     DWORD                     mmap_buflen_bytes;
1969     snd_pcm_uframes_t         mmap_buflen_frames;
1970     snd_pcm_channel_area_t *  mmap_areas;
1971     snd_async_handler_t *     mmap_async_handler;
1972 };
1973
1974 static void DSDB_CheckXRUN(IDsDriverBufferImpl* pdbi)
1975 {
1976     WINE_WAVEOUT *     wwo = &(WOutDev[pdbi->drv->wDevID]);
1977     snd_pcm_state_t    state = snd_pcm_state(wwo->p_handle);
1978
1979     if ( state == SND_PCM_STATE_XRUN )
1980     {
1981         int            err = snd_pcm_prepare(wwo->p_handle);
1982         TRACE("xrun occurred\n");
1983         if ( err < 0 )
1984             ERR("recovery from xrun failed, prepare failed: %s\n", snd_strerror(err));
1985     }
1986     else if ( state == SND_PCM_STATE_SUSPENDED )
1987     {
1988         int            err = snd_pcm_resume(wwo->p_handle);
1989         TRACE("recovery from suspension occurred\n");
1990         if (err < 0 && err != -EAGAIN){
1991             err = snd_pcm_prepare(wwo->p_handle);
1992             if (err < 0)
1993                 ERR("recovery from suspend failed, prepare failed: %s\n", snd_strerror(err));
1994         }
1995     }
1996 }
1997
1998 static void DSDB_MMAPCopy(IDsDriverBufferImpl* pdbi)
1999 {
2000     WINE_WAVEOUT *     wwo = &(WOutDev[pdbi->drv->wDevID]);
2001     int                channels;
2002     snd_pcm_format_t   format;
2003     snd_pcm_uframes_t  period_size;
2004     snd_pcm_sframes_t  avail;
2005
2006     if ( !pdbi->mmap_buffer || !wwo->hw_params || !wwo->p_handle)
2007         return;
2008
2009     channels = snd_pcm_hw_params_get_channels(wwo->hw_params);
2010     format = snd_pcm_hw_params_get_format(wwo->hw_params);
2011     period_size = snd_pcm_hw_params_get_period_size(wwo->hw_params, 0);
2012     avail = snd_pcm_avail_update(wwo->p_handle);
2013
2014     DSDB_CheckXRUN(pdbi);
2015
2016     TRACE("avail=%d format=%s channels=%d\n", (int)avail, snd_pcm_format_name(format), channels );
2017
2018     while (avail >= period_size)
2019     {
2020         const snd_pcm_channel_area_t *areas;
2021         snd_pcm_uframes_t     ofs;
2022         snd_pcm_uframes_t     frames;
2023         int                   err;
2024
2025         frames = avail / period_size * period_size; /* round down to a multiple of period_size */
2026
2027         EnterCriticalSection(&pdbi->mmap_crst);
2028
2029         snd_pcm_mmap_begin(wwo->p_handle, &areas, &ofs, &frames);
2030         snd_pcm_areas_copy(areas, ofs, pdbi->mmap_areas, ofs, channels, frames, format);
2031         err = snd_pcm_mmap_commit(wwo->p_handle, ofs, frames);
2032
2033         LeaveCriticalSection(&pdbi->mmap_crst);
2034
2035         if ( err != (snd_pcm_sframes_t) frames)
2036             ERR("mmap partially failed.\n");
2037
2038         avail = snd_pcm_avail_update(wwo->p_handle);
2039     }
2040  }
2041
2042 static void DSDB_PCMCallback(snd_async_handler_t *ahandler)
2043 {
2044     /* snd_pcm_t *               handle = snd_async_handler_get_pcm(ahandler); */
2045     IDsDriverBufferImpl*      pdbi = snd_async_handler_get_callback_private(ahandler);
2046     TRACE("callback called\n");
2047     DSDB_MMAPCopy(pdbi);
2048 }
2049
2050 static int DSDB_CreateMMAP(IDsDriverBufferImpl* pdbi)
2051  {
2052     WINE_WAVEOUT *            wwo = &(WOutDev[pdbi->drv->wDevID]);
2053     snd_pcm_format_t          format = snd_pcm_hw_params_get_format(wwo->hw_params);
2054     snd_pcm_uframes_t         frames = snd_pcm_hw_params_get_buffer_size(wwo->hw_params);
2055     int                       channels = snd_pcm_hw_params_get_channels(wwo->hw_params);
2056     unsigned int              bits_per_sample = snd_pcm_format_physical_width(format);
2057     unsigned int              bits_per_frame = bits_per_sample * channels;
2058     snd_pcm_channel_area_t *  a;
2059     unsigned int              c;
2060     int                       err;
2061
2062     if (TRACE_ON(wave))
2063         ALSA_TraceParameters(wwo->hw_params, NULL, FALSE);
2064
2065     TRACE("format=%s  frames=%ld  channels=%d  bits_per_sample=%d  bits_per_frame=%d\n",
2066           snd_pcm_format_name(format), frames, channels, bits_per_sample, bits_per_frame);
2067
2068     pdbi->mmap_buflen_frames = frames;
2069     pdbi->mmap_buflen_bytes = snd_pcm_frames_to_bytes( wwo->p_handle, frames );
2070     pdbi->mmap_buffer = HeapAlloc(GetProcessHeap(),0,pdbi->mmap_buflen_bytes);
2071     if (!pdbi->mmap_buffer)
2072         return DSERR_OUTOFMEMORY;
2073
2074     snd_pcm_format_set_silence(format, pdbi->mmap_buffer, frames );
2075
2076     TRACE("created mmap buffer of %ld frames (%ld bytes) at %p\n",
2077         frames, pdbi->mmap_buflen_bytes, pdbi->mmap_buffer);
2078
2079     pdbi->mmap_areas = HeapAlloc(GetProcessHeap(),0,channels*sizeof(snd_pcm_channel_area_t));
2080     if (!pdbi->mmap_areas)
2081         return DSERR_OUTOFMEMORY;
2082
2083     a = pdbi->mmap_areas;
2084     for (c = 0; c < channels; c++, a++)
2085     {
2086         a->addr = pdbi->mmap_buffer;
2087         a->first = bits_per_sample * c;
2088         a->step = bits_per_frame;
2089         TRACE("Area %d: addr=%p  first=%d  step=%d\n", c, a->addr, a->first, a->step);
2090     }
2091
2092     InitializeCriticalSection(&pdbi->mmap_crst);
2093
2094     err = snd_async_add_pcm_handler(&pdbi->mmap_async_handler, wwo->p_handle, DSDB_PCMCallback, pdbi);
2095     if ( err < 0 )
2096      {
2097         ERR("add_pcm_handler failed. reason: %s\n", snd_strerror(err));
2098         return DSERR_GENERIC;
2099      }
2100
2101     return DS_OK;
2102  }
2103
2104 static void DSDB_DestroyMMAP(IDsDriverBufferImpl* pdbi)
2105 {
2106     TRACE("mmap buffer %p destroyed\n", pdbi->mmap_buffer);
2107     HeapFree(GetProcessHeap(), 0, pdbi->mmap_areas);
2108     HeapFree(GetProcessHeap(), 0, pdbi->mmap_buffer);
2109     pdbi->mmap_areas = NULL;
2110     pdbi->mmap_buffer = NULL;
2111     DeleteCriticalSection(&pdbi->mmap_crst);
2112 }
2113
2114
2115 static HRESULT WINAPI IDsDriverBufferImpl_QueryInterface(PIDSDRIVERBUFFER iface, REFIID riid, LPVOID *ppobj)
2116 {
2117     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
2118     FIXME("(): stub!\n");
2119     return DSERR_UNSUPPORTED;
2120 }
2121
2122 static ULONG WINAPI IDsDriverBufferImpl_AddRef(PIDSDRIVERBUFFER iface)
2123 {
2124     ICOM_THIS(IDsDriverBufferImpl,iface);
2125     TRACE("(%p)\n",iface);
2126     return ++This->ref;
2127 }
2128
2129 static ULONG WINAPI IDsDriverBufferImpl_Release(PIDSDRIVERBUFFER iface)
2130 {
2131     ICOM_THIS(IDsDriverBufferImpl,iface);
2132     TRACE("(%p)\n",iface);
2133     if (--This->ref)
2134         return This->ref;
2135     if (This == This->drv->primary)
2136         This->drv->primary = NULL;
2137     DSDB_DestroyMMAP(This);
2138     HeapFree(GetProcessHeap(), 0, This);
2139     return 0;
2140 }
2141
2142 static HRESULT WINAPI IDsDriverBufferImpl_Lock(PIDSDRIVERBUFFER iface,
2143                                                LPVOID*ppvAudio1,LPDWORD pdwLen1,
2144                                                LPVOID*ppvAudio2,LPDWORD pdwLen2,
2145                                                DWORD dwWritePosition,DWORD dwWriteLen,
2146                                                DWORD dwFlags)
2147 {
2148     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
2149     TRACE("(%p)\n",iface);
2150     return DSERR_UNSUPPORTED;
2151 }
2152
2153 static HRESULT WINAPI IDsDriverBufferImpl_Unlock(PIDSDRIVERBUFFER iface,
2154                                                  LPVOID pvAudio1,DWORD dwLen1,
2155                                                  LPVOID pvAudio2,DWORD dwLen2)
2156 {
2157     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
2158     TRACE("(%p)\n",iface);
2159     return DSERR_UNSUPPORTED;
2160 }
2161
2162 static HRESULT WINAPI IDsDriverBufferImpl_SetFormat(PIDSDRIVERBUFFER iface,
2163                                                     LPWAVEFORMATEX pwfx)
2164 {
2165     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
2166     TRACE("(%p,%p)\n",iface,pwfx);
2167     return DSERR_BUFFERLOST;
2168 }
2169
2170 static HRESULT WINAPI IDsDriverBufferImpl_SetFrequency(PIDSDRIVERBUFFER iface, DWORD dwFreq)
2171 {
2172     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
2173     TRACE("(%p,%ld): stub\n",iface,dwFreq);
2174     return DSERR_UNSUPPORTED;
2175 }
2176
2177 static HRESULT WINAPI IDsDriverBufferImpl_SetVolumePan(PIDSDRIVERBUFFER iface, PDSVOLUMEPAN pVolPan)
2178 {
2179     DWORD vol;
2180     ICOM_THIS(IDsDriverBufferImpl,iface);
2181     TRACE("(%p,%p)\n",iface,pVolPan);
2182     vol = pVolPan->dwTotalLeftAmpFactor | (pVolPan->dwTotalRightAmpFactor << 16);
2183
2184     if (wodSetVolume(This->drv->wDevID, vol) != MMSYSERR_NOERROR) {
2185         WARN("wodSetVolume failed\n");
2186         return DSERR_INVALIDPARAM;
2187     }
2188
2189     return DS_OK;
2190 }
2191
2192 static HRESULT WINAPI IDsDriverBufferImpl_SetPosition(PIDSDRIVERBUFFER iface, DWORD dwNewPos)
2193 {
2194     /* ICOM_THIS(IDsDriverImpl,iface); */
2195     TRACE("(%p,%ld): stub\n",iface,dwNewPos);
2196     return DSERR_UNSUPPORTED;
2197 }
2198
2199 static HRESULT WINAPI IDsDriverBufferImpl_GetPosition(PIDSDRIVERBUFFER iface,
2200                                                       LPDWORD lpdwPlay, LPDWORD lpdwWrite)
2201 {
2202     ICOM_THIS(IDsDriverBufferImpl,iface);
2203     WINE_WAVEOUT *      wwo = &(WOutDev[This->drv->wDevID]);
2204     snd_pcm_uframes_t   hw_ptr;
2205     snd_pcm_uframes_t   period_size;
2206
2207     if (wwo->hw_params == NULL) return DSERR_GENERIC;
2208
2209     period_size  = snd_pcm_hw_params_get_period_size(wwo->hw_params, 0);
2210
2211     if (wwo->p_handle == NULL) return DSERR_GENERIC;
2212     /** we need to track down buffer underruns */
2213     DSDB_CheckXRUN(This);
2214
2215     EnterCriticalSection(&This->mmap_crst);
2216     hw_ptr = _snd_pcm_mmap_hw_ptr(wwo->p_handle);
2217     if (lpdwPlay)
2218         *lpdwPlay = snd_pcm_frames_to_bytes(wwo->p_handle, hw_ptr/ period_size  * period_size) % This->mmap_buflen_bytes;
2219     if (lpdwWrite)
2220         *lpdwWrite = snd_pcm_frames_to_bytes(wwo->p_handle, (hw_ptr / period_size + 1) * period_size ) % This->mmap_buflen_bytes;
2221     LeaveCriticalSection(&This->mmap_crst);
2222
2223     TRACE("hw_ptr=0x%08x, playpos=%ld, writepos=%ld\n", (unsigned int)hw_ptr, lpdwPlay?*lpdwPlay:-1, lpdwWrite?*lpdwWrite:-1);
2224     return DS_OK;
2225 }
2226
2227 static HRESULT WINAPI IDsDriverBufferImpl_Play(PIDSDRIVERBUFFER iface, DWORD dwRes1, DWORD dwRes2, DWORD dwFlags)
2228 {
2229     ICOM_THIS(IDsDriverBufferImpl,iface);
2230     WINE_WAVEOUT *       wwo = &(WOutDev[This->drv->wDevID]);
2231     snd_pcm_state_t      state;
2232     int                  err;
2233
2234     TRACE("(%p,%lx,%lx,%lx)\n",iface,dwRes1,dwRes2,dwFlags);
2235
2236     if (wwo->p_handle == NULL) return DSERR_GENERIC;
2237
2238     state = snd_pcm_state(wwo->p_handle);
2239     if ( state == SND_PCM_STATE_SETUP )
2240     {
2241         err = snd_pcm_prepare(wwo->p_handle);
2242         state = snd_pcm_state(wwo->p_handle);
2243     }
2244     if ( state == SND_PCM_STATE_PREPARED )
2245      {
2246         DSDB_MMAPCopy(This);
2247         err = snd_pcm_start(wwo->p_handle);
2248      }
2249     return DS_OK;
2250 }
2251
2252 static HRESULT WINAPI IDsDriverBufferImpl_Stop(PIDSDRIVERBUFFER iface)
2253 {
2254     ICOM_THIS(IDsDriverBufferImpl,iface);
2255     WINE_WAVEOUT *    wwo = &(WOutDev[This->drv->wDevID]);
2256     int               err;
2257     DWORD             play;
2258     DWORD             write;
2259
2260     TRACE("(%p)\n",iface);
2261
2262     if (wwo->p_handle == NULL) return DSERR_GENERIC;
2263
2264     /* ring buffer wrap up detection */
2265     IDsDriverBufferImpl_GetPosition(iface, &play, &write);
2266     if ( play > write)
2267     {
2268         TRACE("writepos wrapper up\n");
2269         return DS_OK;
2270     }
2271
2272     if ( ( err = snd_pcm_drop(wwo->p_handle)) < 0 )
2273     {
2274         ERR("error while stopping pcm: %s\n", snd_strerror(err));
2275         return DSERR_GENERIC;
2276     }
2277     return DS_OK;
2278 }
2279
2280 static ICOM_VTABLE(IDsDriverBuffer) dsdbvt =
2281 {
2282     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2283     IDsDriverBufferImpl_QueryInterface,
2284     IDsDriverBufferImpl_AddRef,
2285     IDsDriverBufferImpl_Release,
2286     IDsDriverBufferImpl_Lock,
2287     IDsDriverBufferImpl_Unlock,
2288     IDsDriverBufferImpl_SetFormat,
2289     IDsDriverBufferImpl_SetFrequency,
2290     IDsDriverBufferImpl_SetVolumePan,
2291     IDsDriverBufferImpl_SetPosition,
2292     IDsDriverBufferImpl_GetPosition,
2293     IDsDriverBufferImpl_Play,
2294     IDsDriverBufferImpl_Stop
2295 };
2296
2297 static HRESULT WINAPI IDsDriverImpl_QueryInterface(PIDSDRIVER iface, REFIID riid, LPVOID *ppobj)
2298 {
2299     /* ICOM_THIS(IDsDriverImpl,iface); */
2300     FIXME("(%p): stub!\n",iface);
2301     return DSERR_UNSUPPORTED;
2302 }
2303
2304 static ULONG WINAPI IDsDriverImpl_AddRef(PIDSDRIVER iface)
2305 {
2306     ICOM_THIS(IDsDriverImpl,iface);
2307     TRACE("(%p)\n",iface);
2308     This->ref++;
2309     return This->ref;
2310 }
2311
2312 static ULONG WINAPI IDsDriverImpl_Release(PIDSDRIVER iface)
2313 {
2314     ICOM_THIS(IDsDriverImpl,iface);
2315     TRACE("(%p)\n",iface);
2316     if (--This->ref)
2317         return This->ref;
2318     HeapFree(GetProcessHeap(),0,This);
2319     return 0;
2320 }
2321
2322 static HRESULT WINAPI IDsDriverImpl_GetDriverDesc(PIDSDRIVER iface, PDSDRIVERDESC pDesc)
2323 {
2324     ICOM_THIS(IDsDriverImpl,iface);
2325     TRACE("(%p,%p)\n",iface,pDesc);
2326     memcpy(pDesc, &(WOutDev[This->wDevID].ds_desc), sizeof(DSDRIVERDESC));
2327     pDesc->dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT |
2328         DSDDESC_USESYSTEMMEMORY | DSDDESC_DONTNEEDPRIMARYLOCK;
2329     pDesc->dnDevNode            = WOutDev[This->wDevID].waveDesc.dnDevNode;
2330     pDesc->wVxdId               = 0;
2331     pDesc->wReserved            = 0;
2332     pDesc->ulDeviceNum          = This->wDevID;
2333     pDesc->dwHeapType           = DSDHEAP_NOHEAP;
2334     pDesc->pvDirectDrawHeap     = NULL;
2335     pDesc->dwMemStartAddress    = 0;
2336     pDesc->dwMemEndAddress      = 0;
2337     pDesc->dwMemAllocExtra      = 0;
2338     pDesc->pvReserved1          = NULL;
2339     pDesc->pvReserved2          = NULL;
2340     return DS_OK;
2341 }
2342
2343 static HRESULT WINAPI IDsDriverImpl_Open(PIDSDRIVER iface)
2344 {
2345     /* ICOM_THIS(IDsDriverImpl,iface); */
2346     TRACE("(%p)\n",iface);
2347     return DS_OK;
2348 }
2349
2350 static HRESULT WINAPI IDsDriverImpl_Close(PIDSDRIVER iface)
2351 {
2352     /* ICOM_THIS(IDsDriverImpl,iface); */
2353     TRACE("(%p)\n",iface);
2354     return DS_OK;
2355 }
2356
2357 static HRESULT WINAPI IDsDriverImpl_GetCaps(PIDSDRIVER iface, PDSDRIVERCAPS pCaps)
2358 {
2359     ICOM_THIS(IDsDriverImpl,iface);
2360     TRACE("(%p,%p)\n",iface,pCaps);
2361     memset(pCaps, 0, sizeof(*pCaps));
2362
2363     pCaps->dwFlags = DSCAPS_PRIMARYMONO;
2364     if ( WOutDev[This->wDevID].caps.wChannels == 2 )
2365         pCaps->dwFlags |= DSCAPS_PRIMARYSTEREO;
2366
2367     if ( WOutDev[This->wDevID].caps.dwFormats & (WAVE_FORMAT_1S08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_4S08 ) )
2368         pCaps->dwFlags |= DSCAPS_PRIMARY8BIT;
2369
2370     if ( WOutDev[This->wDevID].caps.dwFormats & (WAVE_FORMAT_1S16 | WAVE_FORMAT_2S16 | WAVE_FORMAT_4S16))
2371         pCaps->dwFlags |= DSCAPS_PRIMARY16BIT;
2372
2373     pCaps->dwPrimaryBuffers = 1;
2374     TRACE("caps=0x%X\n",(unsigned int)pCaps->dwFlags);
2375     pCaps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
2376     pCaps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
2377
2378     /* the other fields only apply to secondary buffers, which we don't support
2379      * (unless we want to mess with wavetable synthesizers and MIDI) */
2380     return DS_OK;
2381 }
2382
2383 static HRESULT WINAPI IDsDriverImpl_CreateSoundBuffer(PIDSDRIVER iface,
2384                                                       LPWAVEFORMATEX pwfx,
2385                                                       DWORD dwFlags, DWORD dwCardAddress,
2386                                                       LPDWORD pdwcbBufferSize,
2387                                                       LPBYTE *ppbBuffer,
2388                                                       LPVOID *ppvObj)
2389 {
2390     ICOM_THIS(IDsDriverImpl,iface);
2391     IDsDriverBufferImpl** ippdsdb = (IDsDriverBufferImpl**)ppvObj;
2392     int err;
2393
2394     TRACE("(%p,%p,%lx,%lx)\n",iface,pwfx,dwFlags,dwCardAddress);
2395     /* we only support primary buffers */
2396     if (!(dwFlags & DSBCAPS_PRIMARYBUFFER))
2397         return DSERR_UNSUPPORTED;
2398     if (This->primary)
2399         return DSERR_ALLOCATED;
2400     if (dwFlags & (DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN))
2401         return DSERR_CONTROLUNAVAIL;
2402
2403     *ippdsdb = (IDsDriverBufferImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverBufferImpl));
2404     if (*ippdsdb == NULL)
2405         return DSERR_OUTOFMEMORY;
2406     (*ippdsdb)->lpVtbl  = &dsdbvt;
2407     (*ippdsdb)->ref     = 1;
2408     (*ippdsdb)->drv     = This;
2409
2410     err = DSDB_CreateMMAP((*ippdsdb));
2411     if ( err != DS_OK )
2412      {
2413         HeapFree(GetProcessHeap(), 0, *ippdsdb);
2414         *ippdsdb = NULL;
2415         return err;
2416      }
2417     *ppbBuffer = (*ippdsdb)->mmap_buffer;
2418     *pdwcbBufferSize = (*ippdsdb)->mmap_buflen_bytes;
2419
2420     This->primary = *ippdsdb;
2421
2422     /* buffer is ready to go */
2423     TRACE("buffer created at %p\n", *ippdsdb);
2424     return DS_OK;
2425 }
2426
2427 static HRESULT WINAPI IDsDriverImpl_DuplicateSoundBuffer(PIDSDRIVER iface,
2428                                                          PIDSDRIVERBUFFER pBuffer,
2429                                                          LPVOID *ppvObj)
2430 {
2431     /* ICOM_THIS(IDsDriverImpl,iface); */
2432     TRACE("(%p,%p): stub\n",iface,pBuffer);
2433     return DSERR_INVALIDCALL;
2434 }
2435
2436 static ICOM_VTABLE(IDsDriver) dsdvt =
2437 {
2438     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2439     IDsDriverImpl_QueryInterface,
2440     IDsDriverImpl_AddRef,
2441     IDsDriverImpl_Release,
2442     IDsDriverImpl_GetDriverDesc,
2443     IDsDriverImpl_Open,
2444     IDsDriverImpl_Close,
2445     IDsDriverImpl_GetCaps,
2446     IDsDriverImpl_CreateSoundBuffer,
2447     IDsDriverImpl_DuplicateSoundBuffer
2448 };
2449
2450 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
2451 {
2452     IDsDriverImpl** idrv = (IDsDriverImpl**)drv;
2453
2454     TRACE("driver created\n");
2455
2456     /* the HAL isn't much better than the HEL if we can't do mmap() */
2457     if (!(WOutDev[wDevID].caps.dwSupport & WAVECAPS_DIRECTSOUND)) {
2458         ERR("DirectSound flag not set\n");
2459         MESSAGE("This sound card's driver does not support direct access\n");
2460         MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
2461         return MMSYSERR_NOTSUPPORTED;
2462     }
2463
2464     *idrv = (IDsDriverImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverImpl));
2465     if (!*idrv)
2466         return MMSYSERR_NOMEM;
2467     (*idrv)->lpVtbl     = &dsdvt;
2468     (*idrv)->ref        = 1;
2469
2470     (*idrv)->wDevID     = wDevID;
2471     (*idrv)->primary    = NULL;
2472     return MMSYSERR_NOERROR;
2473 }
2474
2475 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
2476 {
2477     memcpy(desc, &(WOutDev[wDevID].ds_desc), sizeof(DSDRIVERDESC));
2478     return MMSYSERR_NOERROR;
2479 }
2480
2481 static DWORD wodDsGuid(UINT wDevID, LPGUID pGuid)
2482 {
2483     TRACE("(%d,%p)\n",wDevID,pGuid);
2484
2485     memcpy(pGuid, &(WOutDev[wDevID].ds_guid), sizeof(GUID));
2486
2487     return MMSYSERR_NOERROR;
2488 }
2489
2490 /*======================================================================*
2491 *                  Low level WAVE IN implementation                     *
2492 *======================================================================*/
2493
2494 /**************************************************************************
2495 *                       widNotifyClient                 [internal]
2496 */
2497 static DWORD widNotifyClient(WINE_WAVEIN* wwi, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
2498 {
2499    TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
2500
2501    switch (wMsg) {
2502    case WIM_OPEN:
2503    case WIM_CLOSE:
2504    case WIM_DATA:
2505        if (wwi->wFlags != DCB_NULL &&
2506            !DriverCallback(wwi->waveDesc.dwCallback, wwi->wFlags, (HDRVR)wwi->waveDesc.hWave,
2507                            wMsg, wwi->waveDesc.dwInstance, dwParam1, dwParam2)) {
2508            WARN("can't notify client !\n");
2509            return MMSYSERR_ERROR;
2510        }
2511        break;
2512    default:
2513        FIXME("Unknown callback message %u\n", wMsg);
2514        return MMSYSERR_INVALPARAM;
2515    }
2516    return MMSYSERR_NOERROR;
2517 }
2518
2519 /**************************************************************************
2520  *                      widGetDevCaps                           [internal]
2521  */
2522 static DWORD widGetDevCaps(WORD wDevID, LPWAVEOUTCAPSA lpCaps, DWORD dwSize)
2523 {
2524     TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
2525
2526     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
2527
2528     if (wDevID >= MAX_WAVEINDRV) {
2529         TRACE("MAX_WAVOUTDRV reached !\n");
2530         return MMSYSERR_BADDEVICEID;
2531     }
2532
2533     memcpy(lpCaps, &WInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
2534     return MMSYSERR_NOERROR;
2535 }
2536
2537 /**************************************************************************
2538  *                              widRecorder_ReadHeaders         [internal]
2539  */
2540 static void widRecorder_ReadHeaders(WINE_WAVEIN * wwi)
2541 {
2542     enum win_wm_message tmp_msg;
2543     DWORD               tmp_param;
2544     HANDLE              tmp_ev;
2545     WAVEHDR*            lpWaveHdr;
2546
2547     while (ALSA_RetrieveRingMessage(&wwi->msgRing, &tmp_msg, &tmp_param, &tmp_ev)) {
2548         if (tmp_msg == WINE_WM_HEADER) {
2549             LPWAVEHDR*  wh;
2550             lpWaveHdr = (LPWAVEHDR)tmp_param;
2551             lpWaveHdr->lpNext = 0;
2552
2553             if (wwi->lpQueuePtr == 0)
2554                 wwi->lpQueuePtr = lpWaveHdr;
2555             else {
2556                 for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
2557                 *wh = lpWaveHdr;
2558             }
2559         } else {
2560             ERR("should only have headers left\n");
2561         }
2562     }
2563 }
2564
2565 /**************************************************************************
2566  *                              widRecorder                     [internal]
2567  */
2568 static  DWORD   CALLBACK        widRecorder(LPVOID pmt)
2569 {
2570     WORD                uDevID = (DWORD)pmt;
2571     WINE_WAVEIN*        wwi = (WINE_WAVEIN*)&WInDev[uDevID];
2572     WAVEHDR*            lpWaveHdr;
2573     DWORD               dwSleepTime;
2574     DWORD               bytesRead;
2575     LPVOID              buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, wwi->dwPeriodSize);
2576     char               *pOffset = buffer;
2577     enum win_wm_message msg;
2578     DWORD               param;
2579     HANDLE              ev;
2580     DWORD               frames_per_period;
2581
2582     wwi->state = WINE_WS_STOPPED;
2583     wwi->dwTotalRecorded = 0;
2584     wwi->lpQueuePtr = NULL;
2585
2586     SetEvent(wwi->hStartUpEvent);
2587
2588     /* make sleep time to be # of ms to output a period */
2589     dwSleepTime = (1024/*wwi-dwPeriodSize => overrun!*/ * 1000) / wwi->format.wf.nAvgBytesPerSec;
2590     frames_per_period = snd_pcm_bytes_to_frames(wwi->p_handle, wwi->dwPeriodSize);
2591     TRACE("sleeptime=%ld ms\n", dwSleepTime);
2592
2593     for (;;) {
2594         /* wait for dwSleepTime or an event in thread's queue */
2595         /* FIXME: could improve wait time depending on queue state,
2596          * ie, number of queued fragments
2597          */
2598         if (wwi->lpQueuePtr != NULL && wwi->state == WINE_WS_PLAYING)
2599         {
2600             int periods;
2601             DWORD frames;
2602             DWORD bytes;
2603             DWORD read;
2604
2605             lpWaveHdr = wwi->lpQueuePtr;
2606             /* read all the fragments accumulated so far */
2607             frames = snd_pcm_avail_update(wwi->p_handle);
2608             bytes = snd_pcm_frames_to_bytes(wwi->p_handle, frames);
2609             TRACE("frames = %ld  bytes = %ld\n", frames, bytes);
2610             periods = bytes / wwi->dwPeriodSize;
2611             while ((periods > 0) && (wwi->lpQueuePtr))
2612             {
2613                 periods--;
2614                 bytes = wwi->dwPeriodSize;
2615                 TRACE("bytes = %ld\n",bytes);
2616                 if (lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded >= wwi->dwPeriodSize)
2617                 {
2618                     /* directly read fragment in wavehdr */
2619                     read = wwi->read(wwi->p_handle, lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded, frames_per_period);
2620                     bytesRead = snd_pcm_frames_to_bytes(wwi->p_handle, read);
2621
2622                     TRACE("bytesRead=%ld (direct)\n", bytesRead);
2623                     if (bytesRead != (DWORD) -1)
2624                     {
2625                         /* update number of bytes recorded in current buffer and by this device */
2626                         lpWaveHdr->dwBytesRecorded += bytesRead;
2627                         wwi->dwTotalRecorded       += bytesRead;
2628
2629                         /* buffer is full. notify client */
2630                         if (lpWaveHdr->dwBytesRecorded == lpWaveHdr->dwBufferLength)
2631                         {
2632                             /* must copy the value of next waveHdr, because we have no idea of what
2633                              * will be done with the content of lpWaveHdr in callback
2634                              */
2635                             LPWAVEHDR   lpNext = lpWaveHdr->lpNext;
2636
2637                             lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2638                             lpWaveHdr->dwFlags |=  WHDR_DONE;
2639
2640                             wwi->lpQueuePtr = lpNext;
2641                             widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
2642                             lpWaveHdr = lpNext;
2643                         }
2644                     }
2645                 }
2646                 else
2647                 {
2648                     /* read the fragment in a local buffer */
2649                     read = wwi->read(wwi->p_handle, buffer, frames_per_period);
2650                     bytesRead = snd_pcm_frames_to_bytes(wwi->p_handle, read);
2651                     pOffset = buffer;
2652
2653                     TRACE("bytesRead=%ld (local)\n", bytesRead);
2654
2655                     /* copy data in client buffers */
2656                     while (bytesRead != (DWORD) -1 && bytesRead > 0)
2657                     {
2658                         DWORD dwToCopy = min (bytesRead, lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded);
2659
2660                         memcpy(lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded,
2661                                pOffset,
2662                                dwToCopy);
2663
2664                         /* update number of bytes recorded in current buffer and by this device */
2665                         lpWaveHdr->dwBytesRecorded += dwToCopy;
2666                         wwi->dwTotalRecorded += dwToCopy;
2667                         bytesRead -= dwToCopy;
2668                         pOffset   += dwToCopy;
2669
2670                         /* client buffer is full. notify client */
2671                         if (lpWaveHdr->dwBytesRecorded == lpWaveHdr->dwBufferLength)
2672                         {
2673                             /* must copy the value of next waveHdr, because we have no idea of what
2674                              * will be done with the content of lpWaveHdr in callback
2675                              */
2676                             LPWAVEHDR   lpNext = lpWaveHdr->lpNext;
2677                             TRACE("lpNext=%p\n", lpNext);
2678
2679                             lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2680                             lpWaveHdr->dwFlags |=  WHDR_DONE;
2681
2682                             wwi->lpQueuePtr = lpNext;
2683                             widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
2684
2685                             lpWaveHdr = lpNext;
2686                             if (!lpNext && bytesRead) {
2687                                 /* before we give up, check for more header messages */
2688                                 while (ALSA_PeekRingMessage(&wwi->msgRing, &msg, &param, &ev))
2689                                 {
2690                                     if (msg == WINE_WM_HEADER) {
2691                                         LPWAVEHDR hdr;
2692                                         ALSA_RetrieveRingMessage(&wwi->msgRing, &msg, &param, &ev);
2693                                         hdr = ((LPWAVEHDR)param);
2694                                         TRACE("msg = %s, hdr = %p, ev = %p\n", wodPlayerCmdString[msg - WM_USER - 1], hdr, ev);
2695                                         hdr->lpNext = 0;
2696                                         if (lpWaveHdr == 0) {
2697                                             /* new head of queue */
2698                                             wwi->lpQueuePtr = lpWaveHdr = hdr;
2699                                         } else {
2700                                             /* insert buffer at the end of queue */
2701                                             LPWAVEHDR*  wh;
2702                                             for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
2703                                             *wh = hdr;
2704                                         }
2705                                     } else
2706                                         break;
2707                                 }
2708
2709                                 if (lpWaveHdr == 0) {
2710                                     /* no more buffer to copy data to, but we did read more.
2711                                      * what hasn't been copied will be dropped
2712                                      */
2713                                     WARN("buffer under run! %lu bytes dropped.\n", bytesRead);
2714                                     wwi->lpQueuePtr = NULL;
2715                                     break;
2716                                 }
2717                             }
2718                         }
2719                     }
2720                 }
2721             }
2722         }
2723
2724         WAIT_OMR(&wwi->msgRing, dwSleepTime);
2725
2726         while (ALSA_RetrieveRingMessage(&wwi->msgRing, &msg, &param, &ev))
2727         {
2728             TRACE("msg=%s param=0x%lx\n", wodPlayerCmdString[msg - WM_USER - 1], param);
2729             switch (msg) {
2730             case WINE_WM_PAUSING:
2731                 wwi->state = WINE_WS_PAUSED;
2732                 /*FIXME("Device should stop recording\n");*/
2733                 SetEvent(ev);
2734                 break;
2735             case WINE_WM_STARTING:
2736                 wwi->state = WINE_WS_PLAYING;
2737                 snd_pcm_start(wwi->p_handle);
2738                 SetEvent(ev);
2739                 break;
2740             case WINE_WM_HEADER:
2741                 lpWaveHdr = (LPWAVEHDR)param;
2742                 lpWaveHdr->lpNext = 0;
2743
2744                 /* insert buffer at the end of queue */
2745                 {
2746                     LPWAVEHDR*  wh;
2747                     for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
2748                     *wh = lpWaveHdr;
2749                 }
2750                 break;
2751             case WINE_WM_STOPPING:
2752                 if (wwi->state != WINE_WS_STOPPED)
2753                 {
2754                     snd_pcm_drain(wwi->p_handle);
2755
2756                     /* read any headers in queue */
2757                     widRecorder_ReadHeaders(wwi);
2758
2759                     /* return current buffer to app */
2760                     lpWaveHdr = wwi->lpQueuePtr;
2761                     if (lpWaveHdr)
2762                     {
2763                         LPWAVEHDR       lpNext = lpWaveHdr->lpNext;
2764                         TRACE("stop %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
2765                         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2766                         lpWaveHdr->dwFlags |= WHDR_DONE;
2767                         wwi->lpQueuePtr = lpNext;
2768                         widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
2769                     }
2770                 }
2771                 wwi->state = WINE_WS_STOPPED;
2772                 SetEvent(ev);
2773                 break;
2774             case WINE_WM_RESETTING:
2775                 if (wwi->state != WINE_WS_STOPPED)
2776                 {
2777                     snd_pcm_drain(wwi->p_handle);
2778                 }
2779                 wwi->state = WINE_WS_STOPPED;
2780                 wwi->dwTotalRecorded = 0;
2781
2782                 /* read any headers in queue */
2783                 widRecorder_ReadHeaders(wwi);
2784
2785                 /* return all buffers to the app */
2786                 for (lpWaveHdr = wwi->lpQueuePtr; lpWaveHdr; lpWaveHdr = lpWaveHdr->lpNext) {
2787                     TRACE("reset %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
2788                     lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2789                     lpWaveHdr->dwFlags |= WHDR_DONE;
2790                     wwi->lpQueuePtr = lpWaveHdr->lpNext;
2791                     widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
2792                 }
2793
2794                 wwi->lpQueuePtr = NULL;
2795                 SetEvent(ev);
2796                 break;
2797             case WINE_WM_CLOSING:
2798                 wwi->hThread = 0;
2799                 wwi->state = WINE_WS_CLOSED;
2800                 SetEvent(ev);
2801                 HeapFree(GetProcessHeap(), 0, buffer);
2802                 ExitThread(0);
2803                 /* shouldn't go here */
2804             case WINE_WM_UPDATE:
2805                 SetEvent(ev);
2806                 break;
2807
2808             default:
2809                 FIXME("unknown message %d\n", msg);
2810                 break;
2811             }
2812         }
2813     }
2814     ExitThread(0);
2815     /* just for not generating compilation warnings... should never be executed */
2816     return 0;
2817 }
2818
2819 /**************************************************************************
2820  *                              widOpen                         [internal]
2821  */
2822 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
2823 {
2824     WINE_WAVEIN*                wwi;
2825     snd_pcm_hw_params_t *       hw_params;
2826     snd_pcm_sw_params_t *       sw_params;
2827     snd_pcm_access_t            access;
2828     snd_pcm_format_t            format;
2829     int                         rate;
2830     unsigned int                buffer_time = 500000;
2831     unsigned int                period_time = 10000;
2832     int                         buffer_size;
2833     snd_pcm_uframes_t           period_size;
2834     int                         flags;
2835     snd_pcm_t *                 pcm;
2836     int                         err;
2837
2838     snd_pcm_hw_params_alloca(&hw_params);
2839     snd_pcm_sw_params_alloca(&sw_params);
2840
2841     TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
2842     if (lpDesc == NULL) {
2843         WARN("Invalid Parameter !\n");
2844         return MMSYSERR_INVALPARAM;
2845     }
2846     if (wDevID >= MAX_WAVEOUTDRV) {
2847         TRACE("MAX_WAVOUTDRV reached !\n");
2848         return MMSYSERR_BADDEVICEID;
2849     }
2850
2851     /* only PCM format is supported so far... */
2852     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
2853         lpDesc->lpFormat->nChannels == 0 ||
2854         lpDesc->lpFormat->nSamplesPerSec == 0) {
2855         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
2856              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
2857              lpDesc->lpFormat->nSamplesPerSec);
2858         return WAVERR_BADFORMAT;
2859     }
2860
2861     if (dwFlags & WAVE_FORMAT_QUERY) {
2862         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
2863              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
2864              lpDesc->lpFormat->nSamplesPerSec);
2865         return MMSYSERR_NOERROR;
2866     }
2867
2868     wwi = &WInDev[wDevID];
2869
2870     if ((dwFlags & WAVE_DIRECTSOUND) && !(wwi->caps.dwSupport & WAVECAPS_DIRECTSOUND))
2871         /* not supported, ignore it */
2872         dwFlags &= ~WAVE_DIRECTSOUND;
2873
2874     wwi->p_handle = 0;
2875     flags = SND_PCM_NONBLOCK;
2876     if ( dwFlags & WAVE_DIRECTSOUND )
2877         flags |= SND_PCM_ASYNC;
2878
2879     if ( (err=snd_pcm_open(&pcm, wwi->device, SND_PCM_STREAM_CAPTURE, dwFlags)) < 0 )
2880     {
2881         ERR("Error open: %s\n", snd_strerror(err));
2882         return MMSYSERR_NOTENABLED;
2883     }
2884
2885     wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2886
2887     memcpy(&wwi->waveDesc, lpDesc,           sizeof(WAVEOPENDESC));
2888     memcpy(&wwi->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
2889
2890     if (wwi->format.wBitsPerSample == 0) {
2891         WARN("Resetting zeroed wBitsPerSample\n");
2892         wwi->format.wBitsPerSample = 8 *
2893             (wwi->format.wf.nAvgBytesPerSec /
2894              wwi->format.wf.nSamplesPerSec) /
2895             wwi->format.wf.nChannels;
2896     }
2897
2898     snd_pcm_hw_params_any(pcm, hw_params);
2899
2900 #define EXIT_ON_ERROR(f,e,txt) do \
2901 { \
2902     int err; \
2903     if ( (err = (f) ) < 0) \
2904     { \
2905         ERR(txt ": %s\n", snd_strerror(err)); \
2906         snd_pcm_close(pcm); \
2907         return e; \
2908     } \
2909 } while(0)
2910
2911     access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
2912     if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
2913         WARN("mmap not available. switching to standard write.\n");
2914         access = SND_PCM_ACCESS_RW_INTERLEAVED;
2915         EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
2916         wwi->read = snd_pcm_readi;
2917     }
2918     else
2919         wwi->read = snd_pcm_mmap_readi;
2920
2921     EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwi->format.wf.nChannels), MMSYSERR_INVALPARAM, "unable to set required channels");
2922
2923     format = (wwi->format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE : SND_PCM_FORMAT_U8;
2924     EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), MMSYSERR_INVALPARAM, "unable to set required format");
2925
2926     rate = snd_pcm_hw_params_set_rate_near(pcm, hw_params, wwi->format.wf.nSamplesPerSec, 0);
2927     if (rate < 0) {
2928         ERR("Rate %ld Hz not available for playback: %s\n", wwi->format.wf.nSamplesPerSec, snd_strerror(rate));
2929         snd_pcm_close(pcm);
2930         return WAVERR_BADFORMAT;
2931     }
2932     if (rate != wwi->format.wf.nSamplesPerSec) {
2933         ERR("Rate doesn't match (requested %ld Hz, got %d Hz)\n", wwi->format.wf.nSamplesPerSec, rate);
2934         snd_pcm_close(pcm);
2935         return WAVERR_BADFORMAT;
2936     }
2937
2938     EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, buffer_time, 0), MMSYSERR_INVALPARAM, "unable to set buffer time");
2939     EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm, hw_params, period_time, 0), MMSYSERR_INVALPARAM, "unable to set period time");
2940
2941     EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
2942
2943     period_size = snd_pcm_hw_params_get_period_size(hw_params, 0);
2944     buffer_size = snd_pcm_hw_params_get_buffer_size(hw_params);
2945
2946     snd_pcm_sw_params_current(pcm, sw_params);
2947     EXIT_ON_ERROR( snd_pcm_sw_params_set_start_threshold(pcm, sw_params, dwFlags & WAVE_DIRECTSOUND ? INT_MAX : 1 ), MMSYSERR_ERROR, "unable to set start threshold");
2948     EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence size");
2949     EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
2950     EXIT_ON_ERROR( snd_pcm_sw_params_set_xfer_align(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set xfer align");
2951     EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
2952     EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
2953 #undef EXIT_ON_ERROR
2954
2955     snd_pcm_prepare(pcm);
2956
2957     if (TRACE_ON(wave))
2958         ALSA_TraceParameters(hw_params, sw_params, FALSE);
2959
2960     /* now, we can save all required data for later use... */
2961     if ( wwi->hw_params )
2962         snd_pcm_hw_params_free(wwi->hw_params);
2963     snd_pcm_hw_params_malloc(&(wwi->hw_params));
2964     snd_pcm_hw_params_copy(wwi->hw_params, hw_params);
2965
2966     wwi->dwBufferSize = buffer_size;
2967     wwi->lpQueuePtr = wwi->lpPlayPtr = wwi->lpLoopPtr = NULL;
2968     wwi->p_handle = pcm;
2969
2970     ALSA_InitRingMessage(&wwi->msgRing);
2971
2972     wwi->count = snd_pcm_poll_descriptors_count (wwi->p_handle);
2973     if (wwi->count <= 0) {
2974         ERR("Invalid poll descriptors count\n");
2975         return MMSYSERR_ERROR;
2976     }
2977
2978     wwi->ufds = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(struct pollfd) * wwi->count);
2979     if (wwi->ufds == NULL) {
2980         ERR("No enough memory\n");
2981         return MMSYSERR_NOMEM;
2982     }
2983     if ((err = snd_pcm_poll_descriptors(wwi->p_handle, wwi->ufds, wwi->count)) < 0) {
2984         ERR("Unable to obtain poll descriptors for playback: %s\n", snd_strerror(err));
2985         return MMSYSERR_ERROR;
2986     }
2987
2988     wwi->dwPeriodSize = period_size;
2989     /*if (wwi->dwFragmentSize % wwi->format.wf.nBlockAlign)
2990         ERR("Fragment doesn't contain an integral number of data blocks\n");
2991     */
2992     TRACE("dwPeriodSize=%lu\n", wwi->dwPeriodSize);
2993     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n",
2994           wwi->format.wBitsPerSample, wwi->format.wf.nAvgBytesPerSec,
2995           wwi->format.wf.nSamplesPerSec, wwi->format.wf.nChannels,
2996           wwi->format.wf.nBlockAlign);
2997
2998     if (!(dwFlags & WAVE_DIRECTSOUND)) {
2999         wwi->hStartUpEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
3000         wwi->hThread = CreateThread(NULL, 0, widRecorder, (LPVOID)(DWORD)wDevID, 0, &(wwi->dwThreadID));
3001         WaitForSingleObject(wwi->hStartUpEvent, INFINITE);
3002         CloseHandle(wwi->hStartUpEvent);
3003     } else {
3004         wwi->hThread = INVALID_HANDLE_VALUE;
3005         wwi->dwThreadID = 0;
3006     }
3007     wwi->hStartUpEvent = INVALID_HANDLE_VALUE;
3008
3009     return widNotifyClient(wwi, WIM_OPEN, 0L, 0L);
3010 }
3011
3012
3013 /**************************************************************************
3014  *                              widClose                        [internal]
3015  */
3016 static DWORD widClose(WORD wDevID)
3017 {
3018     DWORD               ret = MMSYSERR_NOERROR;
3019     WINE_WAVEIN*        wwi;
3020
3021     TRACE("(%u);\n", wDevID);
3022
3023     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].p_handle == NULL) {
3024         WARN("bad device ID !\n");
3025         return MMSYSERR_BADDEVICEID;
3026     }
3027
3028     wwi = &WInDev[wDevID];
3029     if (wwi->lpQueuePtr) {
3030         WARN("buffers still playing !\n");
3031         ret = WAVERR_STILLPLAYING;
3032     } else {
3033         if (wwi->hThread != INVALID_HANDLE_VALUE) {
3034             ALSA_AddRingMessage(&wwi->msgRing, WINE_WM_CLOSING, 0, TRUE);
3035         }
3036         ALSA_DestroyRingMessage(&wwi->msgRing);
3037
3038         snd_pcm_hw_params_free(wwi->hw_params);
3039         wwi->hw_params = NULL;
3040
3041         snd_pcm_close(wwi->p_handle);
3042         wwi->p_handle = NULL;
3043
3044         ret = widNotifyClient(wwi, WIM_CLOSE, 0L, 0L);
3045     }
3046
3047     HeapFree(GetProcessHeap(), 0, wwi->ufds);
3048     return ret;
3049 }
3050
3051 /**************************************************************************
3052  *                              widAddBuffer                    [internal]
3053  *
3054  */
3055 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
3056 {
3057     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
3058
3059     /* first, do the sanity checks... */
3060     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].p_handle == NULL) {
3061         WARN("bad dev ID !\n");
3062         return MMSYSERR_BADDEVICEID;
3063     }
3064
3065     if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
3066         return WAVERR_UNPREPARED;
3067
3068     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
3069         return WAVERR_STILLPLAYING;
3070
3071     lpWaveHdr->dwFlags &= ~WHDR_DONE;
3072     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
3073     lpWaveHdr->lpNext = 0;
3074
3075     ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
3076
3077     return MMSYSERR_NOERROR;
3078 }
3079
3080 /**************************************************************************
3081  *                              widPrepare                      [internal]
3082  */
3083 static DWORD widPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
3084 {
3085     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
3086
3087     if (wDevID >= MAX_WAVEINDRV) {
3088         WARN("bad device ID !\n");
3089         return MMSYSERR_BADDEVICEID;
3090     }
3091
3092     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
3093         return WAVERR_STILLPLAYING;
3094
3095     lpWaveHdr->dwFlags |= WHDR_PREPARED;
3096     lpWaveHdr->dwFlags &= ~WHDR_DONE;
3097     return MMSYSERR_NOERROR;
3098 }
3099
3100 /**************************************************************************
3101  *                              widUnprepare                    [internal]
3102  */
3103 static DWORD widUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
3104 {
3105     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
3106
3107     if (wDevID >= MAX_WAVEINDRV) {
3108         WARN("bad device ID !\n");
3109         return MMSYSERR_BADDEVICEID;
3110     }
3111
3112     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
3113         return WAVERR_STILLPLAYING;
3114
3115     lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
3116     lpWaveHdr->dwFlags |= WHDR_DONE;
3117
3118     return MMSYSERR_NOERROR;
3119 }
3120
3121 /**************************************************************************
3122  *                              widStart                        [internal]
3123  *
3124  */
3125 static DWORD widStart(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
3126 {
3127     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
3128
3129     /* first, do the sanity checks... */
3130     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].p_handle == NULL) {
3131         WARN("bad dev ID !\n");
3132         return MMSYSERR_BADDEVICEID;
3133     }
3134
3135     ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_STARTING, 0, TRUE);
3136
3137     Sleep(500);
3138
3139     return MMSYSERR_NOERROR;
3140 }
3141
3142 /**************************************************************************
3143  *                              widStop                 [internal]
3144  *
3145  */
3146 static DWORD widStop(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
3147 {
3148     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
3149
3150     /* first, do the sanity checks... */
3151     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].p_handle == NULL) {
3152         WARN("bad dev ID !\n");
3153         return MMSYSERR_BADDEVICEID;
3154     }
3155
3156     ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_STOPPING, 0, TRUE);
3157
3158     return MMSYSERR_NOERROR;
3159 }
3160
3161 /**************************************************************************
3162  *                      widReset                                [internal]
3163  */
3164 static DWORD widReset(WORD wDevID)
3165 {
3166     TRACE("(%u);\n", wDevID);
3167     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
3168         WARN("can't reset !\n");
3169         return MMSYSERR_INVALHANDLE;
3170     }
3171     ALSA_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
3172     return MMSYSERR_NOERROR;
3173 }
3174
3175 /**************************************************************************
3176  *                              widGetPosition                  [internal]
3177  */
3178 static DWORD widGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
3179 {
3180     int                 time;
3181     WINE_WAVEIN*        wwi;
3182
3183     FIXME("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
3184
3185     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
3186         WARN("can't get pos !\n");
3187         return MMSYSERR_INVALHANDLE;
3188     }
3189     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
3190
3191     wwi = &WInDev[wDevID];
3192     ALSA_AddRingMessage(&wwi->msgRing, WINE_WM_UPDATE, 0, TRUE);
3193
3194     TRACE("wType=%04X !\n", lpTime->wType);
3195     TRACE("wBitsPerSample=%u\n", wwi->format.wBitsPerSample);
3196     TRACE("nSamplesPerSec=%lu\n", wwi->format.wf.nSamplesPerSec);
3197     TRACE("nChannels=%u\n", wwi->format.wf.nChannels);
3198     TRACE("nAvgBytesPerSec=%lu\n", wwi->format.wf.nAvgBytesPerSec);
3199     FIXME("dwTotalRecorded=%lu\n",wwi->dwTotalRecorded);
3200     switch (lpTime->wType) {
3201     case TIME_BYTES:
3202         lpTime->u.cb = wwi->dwTotalRecorded;
3203         TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
3204         break;
3205     case TIME_SAMPLES:
3206         lpTime->u.sample = wwi->dwTotalRecorded * 8 /
3207             wwi->format.wBitsPerSample / wwi->format.wf.nChannels;
3208         TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
3209         break;
3210     case TIME_SMPTE:
3211         time = wwi->dwTotalRecorded /
3212             (wwi->format.wf.nAvgBytesPerSec / 1000);
3213         lpTime->u.smpte.hour = time / (60 * 60 * 1000);
3214         time -= lpTime->u.smpte.hour * (60 * 60 * 1000);
3215         lpTime->u.smpte.min = time / (60 * 1000);
3216         time -= lpTime->u.smpte.min * (60 * 1000);
3217         lpTime->u.smpte.sec = time / 1000;
3218         time -= lpTime->u.smpte.sec * 1000;
3219         lpTime->u.smpte.frame = time * 30 / 1000;
3220         lpTime->u.smpte.fps = 30;
3221         TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
3222               lpTime->u.smpte.hour, lpTime->u.smpte.min,
3223               lpTime->u.smpte.sec, lpTime->u.smpte.frame);
3224         break;
3225     default:
3226         FIXME("format not supported (%u) ! use TIME_MS !\n", lpTime->wType);
3227         lpTime->wType = TIME_MS;
3228     case TIME_MS:
3229         lpTime->u.ms = wwi->dwTotalRecorded /
3230             (wwi->format.wf.nAvgBytesPerSec / 1000);
3231         TRACE("TIME_MS=%lu\n", lpTime->u.ms);
3232         break;
3233     }
3234     return MMSYSERR_NOERROR;
3235 }
3236
3237 /**************************************************************************
3238  *                              widGetNumDevs                   [internal]
3239  */
3240 static  DWORD   widGetNumDevs(void)
3241 {
3242     return ALSA_WidNumDevs;
3243 }
3244
3245 /**************************************************************************
3246  *                              widMessage (WINEALSA.@)
3247  */
3248 DWORD WINAPI ALSA_widMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
3249                              DWORD dwParam1, DWORD dwParam2)
3250 {
3251     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
3252           wDevID, wMsg, dwUser, dwParam1, dwParam2);
3253
3254     switch (wMsg) {
3255     case DRVM_INIT:
3256     case DRVM_EXIT:
3257     case DRVM_ENABLE:
3258     case DRVM_DISABLE:
3259         /* FIXME: Pretend this is supported */
3260         return 0;
3261     case WIDM_OPEN:             return widOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,      dwParam2);
3262     case WIDM_CLOSE:            return widClose         (wDevID);
3263     case WIDM_ADDBUFFER:        return widAddBuffer     (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
3264     case WIDM_PREPARE:          return widPrepare       (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
3265     case WIDM_UNPREPARE:        return widUnprepare     (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
3266     case WIDM_GETDEVCAPS:       return widGetDevCaps    (wDevID, (LPWAVEOUTCAPSA)dwParam1,      dwParam2);
3267     case WIDM_GETNUMDEVS:       return widGetNumDevs    ();
3268     case WIDM_GETPOS:           return widGetPosition   (wDevID, (LPMMTIME)dwParam1,            dwParam2);
3269     case WIDM_RESET:            return widReset         (wDevID);
3270     case WIDM_START:            return widStart (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
3271     case WIDM_STOP:             return widStop  (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
3272     /*case DRV_QUERYDEVICEINTERFACESIZE: return wdDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
3273     case DRV_QUERYDEVICEINTERFACE:     return wdDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
3274     case DRV_QUERYDSOUNDIFACE:  return widDsCreate   (wDevID, (PIDSCDRIVER*)dwParam1);
3275     case DRV_QUERYDSOUNDDESC:   return widDsDesc     (wDevID, (PDSDRIVERDESC)dwParam1);
3276     case DRV_QUERYDSOUNDGUID:   return widDsGuid     (wDevID, (LPGUID)dwParam1);*/
3277     default:
3278         FIXME("unknown message %d!\n", wMsg);
3279     }
3280     return MMSYSERR_NOTSUPPORTED;
3281 }
3282
3283 #endif
3284
3285 #if !(defined(HAVE_ALSA) && ((SND_LIB_MAJOR == 0 && SND_LIB_MINOR >= 9) || SND_LIB_MAJOR >= 1))
3286
3287 /**************************************************************************
3288  *                              widMessage (WINEALSA.@)
3289  */
3290 DWORD WINAPI ALSA_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
3291                              DWORD dwParam1, DWORD dwParam2)
3292 {
3293     FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
3294     return MMSYSERR_NOTENABLED;
3295 }
3296
3297 #endif
3298
3299 #ifndef HAVE_ALSA
3300
3301 /**************************************************************************
3302  *                              wodMessage (WINEALSA.@)
3303  */
3304 DWORD WINAPI ALSA_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
3305                              DWORD dwParam1, DWORD dwParam2)
3306 {
3307     FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
3308     return MMSYSERR_NOTENABLED;
3309 }
3310
3311 #endif /* HAVE_ALSA */