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

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /*
   3  * Wine Driver for Libaudioio
   4  * Derived from the Wine OSS Sample Driver
   5  * Copyright 1994 Martin Ayotte
   6  *           1999 Eric Pouech (async playing in waveOut/waveIn)
   7  *           2000 Eric Pouech (loops in waveOut)
   8  *           2002 Robert Lunnon (Modifications for libaudioio)
   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  * Note large hacks done to effectively  disable DSound altogether
  26  *  Also Input is not yet working (Lots more work to be done there)
  27   * But this does make a reasonable output driver for solaris untill the arts driver comes up to speed
  28  */
  29
  30 /*
  31  * FIXME:
  32  *      pause in waveOut does not work correctly
  33  *      full duplex (in/out) is not working (device is opened twice for Out
  34  *      and In) (OSS is known for its poor duplex capabilities, alsa is
  35  *      better)
  36  */
  37
  38 /*#define EMULATE_SB16*/
  39
  40 #include "config.h"
  41
  42 #include <stdlib.h>
  43 #include <stdio.h>
  44 #include <string.h>
  45 #ifdef HAVE_UNISTD_H
  46 # include <unistd.h>
  47 #endif
  48 #include <errno.h>
  49 #include <fcntl.h>
  50 #ifdef HAVE_SYS_IOCTL_H
  51 # include <sys/ioctl.h>
  52 #endif
  53 #ifdef HAVE_SYS_MMAN_H
  54 # include <sys/mman.h>
  55 #endif
  56 #ifdef HAVE_LIBAUDIOIO_H
  57 #include <libaudioio.h>
  58 #endif
  59 #include "windef.h"
  60 #include "wingdi.h"
  61 #include "winerror.h"
  62 #include "wine/winuser16.h"
  63 #include "mmddk.h"
  64 #include "dsound.h"
  65 #include "dsdriver.h"
  66 #include "wine/debug.h"
  67
  68 WINE_DEFAULT_DEBUG_CHANNEL(wave);
  69
  70 #ifdef HAVE_LIBAUDIOIO
  71
  72 /* Allow 1% deviation for sample rates (some ES137x cards) */
  73 #define NEAR_MATCH(rate1,rate2) (((100*((int)(rate1)-(int)(rate2)))/(rate1))==0)
  74
  75 #define SOUND_DEV "/dev/audio"
  76 #define DEFAULT_FRAGMENT_SIZE 4096
  77
  78
  79
  80 #define MAX_WAVEOUTDRV  (1)
  81 #define MAX_WAVEINDRV   (1)
  82
  83 /* state diagram for waveOut writing:
  84  *
  85  * +---------+-------------+---------------+---------------------------------+
  86  * |  state  |  function   |     event     |            new state            |
  87  * +---------+-------------+---------------+---------------------------------+
  88  * |         | open()      |               | STOPPED                         |
  89  * | PAUSED  | write()     |               | PAUSED                          |
  90  * | STOPPED | write()     | <thrd create> | PLAYING                         |
  91  * | PLAYING | write()     | HEADER        | PLAYING                         |
  92  * | (other) | write()     | <error>       |                                 |
  93  * | (any)   | pause()     | PAUSING       | PAUSED                          |
  94  * | PAUSED  | restart()   | RESTARTING    | PLAYING (if no thrd => STOPPED) |
  95  * | (any)   | reset()     | RESETTING     | STOPPED                         |
  96  * | (any)   | close()     | CLOSING       | CLOSED                          |
  97  * +---------+-------------+---------------+---------------------------------+
  98  */
  99
 100 /* states of the playing device */
 101 #define WINE_WS_PLAYING         0
 102 #define WINE_WS_PAUSED          1
 103 #define WINE_WS_STOPPED         2
 104 #define WINE_WS_CLOSED          3
 105
 106 /* events to be send to device */
 107 #define WINE_WM_PAUSING         (WM_USER + 1)
 108 #define WINE_WM_RESTARTING      (WM_USER + 2)
 109 #define WINE_WM_RESETTING       (WM_USER + 3)
 110 #define WINE_WM_CLOSING         (WM_USER + 4)
 111 #define WINE_WM_HEADER          (WM_USER + 5)
 112
 113 #define WINE_WM_FIRST WINE_WM_PAUSING
 114 #define WINE_WM_LAST WINE_WM_HEADER
 115
 116 typedef struct {
 117     int msg;
 118     DWORD param;
 119 } WWO_MSG;
 120
 121 typedef struct {
 122     int                         unixdev;
 123     volatile int                state;                  /* one of the WINE_WS_ manifest constants */
 124     DWORD                       dwFragmentSize;         /* size of OSS buffer fragment */
 125     WAVEOPENDESC                waveDesc;
 126     WORD                        wFlags;
 127     PCMWAVEFORMAT               format;
 128     LPWAVEHDR                   lpQueuePtr;             /* start of queued WAVEHDRs (waiting to be notified) */
 129     LPWAVEHDR                   lpPlayPtr;              /* start of not yet fully played buffers */
 130     LPWAVEHDR                   lpLoopPtr;              /* pointer of first buffer in loop, if any */
 131     DWORD                       dwLoops;                /* private copy of loop counter */
 132
 133     DWORD                       dwLastFragDone;         /* time in ms, when last played fragment will be actually played */
 134     DWORD                       dwPlayedTotal;          /* number of bytes played since opening */
 135
 136     /* info on current lpQueueHdr->lpWaveHdr */
 137     DWORD                       dwOffCurrHdr;           /* offset in lpPlayPtr->lpData for fragments */
 138     DWORD                       dwRemain;               /* number of bytes to write to end the current fragment  */
 139
 140     /* synchronization stuff */
 141     HANDLE                      hThread;
 142     DWORD                       dwThreadID;
 143     HANDLE                      hEvent;
 144 #define WWO_RING_BUFFER_SIZE    30
 145     WWO_MSG                     messages[WWO_RING_BUFFER_SIZE];
 146     int                         msg_tosave;
 147     int                         msg_toget;
 148     HANDLE                      msg_event;
 149     CRITICAL_SECTION            msg_crst;
 150     WAVEOUTCAPSA                caps;
 151
 152     /* DirectSound stuff */
 153     LPBYTE                      mapping;
 154     DWORD                       maplen;
 155 } WINE_WAVEOUT;
 156
 157 typedef struct {
 158     int                         unixdev;
 159     volatile int                state;
 160     DWORD                       dwFragmentSize;         /* OpenSound '/dev/dsp' give us that size */
 161     WAVEOPENDESC                waveDesc;
 162     WORD                        wFlags;
 163     PCMWAVEFORMAT               format;
 164     LPWAVEHDR                   lpQueuePtr;
 165     DWORD                       dwTotalRecorded;
 166     WAVEINCAPSA                 caps;
 167     BOOL                        bTriggerSupport;
 168
 169     /* synchronization stuff */
 170     HANDLE                      hThread;
 171     DWORD                       dwThreadID;
 172     HANDLE                      hEvent;
 173 } WINE_WAVEIN;
 174
 175 static WINE_WAVEOUT     WOutDev   [MAX_WAVEOUTDRV];
 176 static WINE_WAVEIN      WInDev    [MAX_WAVEINDRV ];
 177
 178 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv);
 179 static DWORD widDsCreate(UINT wDevID, PIDSCDRIVER* drv);
 180 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc);
 181 static DWORD widDsDesc(UINT wDevID, PDSDRIVERDESC desc);
 182 static DWORD wodDsGuid(UINT wDevID, LPGUID pGuid);
 183 static DWORD widDsGuid(UINT wDevID, LPGUID pGuid);
 184
 185 /*======================================================================*
 186  *                  Low level WAVE implementation                       *
 187  *======================================================================*/
 188 SampleSpec_t spec[2];
 189
 190
 191
 192 LONG LIBAUDIOIO_WaveInit(void)
 193 {
 194     int         audio;
 195     int         smplrate;
 196     int         samplesize = 16;
 197     int         dsp_stereo = 1;
 198     int         bytespersmpl;
 199     int         caps;
 200     int         mask;
 201         int     i;
 202
 203         int audio_fd;
 204         int mode;
 205     TRACE("Init ENTERED rate = %d\n",spec[PLAYBACK].rate);
 206        spec[RECORD].channels=spec[PLAYBACK].channels=2;
 207         spec[RECORD].max_blocks=spec[PLAYBACK].max_blocks=16;
 208         spec[RECORD].rate=spec[PLAYBACK].rate=44100;
 209         spec[RECORD].encoding=spec[PLAYBACK].encoding= ENCODE_PCM;
 210         spec[RECORD].precision=spec[PLAYBACK].precision=16 ;
 211         spec[RECORD].endian=spec[PLAYBACK].endian=ENDIAN_INTEL;
 212         spec[RECORD].disable_threads=spec[PLAYBACK].disable_threads=1;
 213         spec[RECORD].type=spec[PLAYBACK].type=TYPE_SIGNED; /* in 16 bit mode this is what typical PC hardware expects */
 214
 215         mode = O_WRONLY|O_NDELAY;
 216
 217         /* start with output device */
 218
 219         /* initialize all device handles to -1 */
 220         for (i = 0; i < MAX_WAVEOUTDRV; ++i)
 221         {
 222                 WOutDev[i].unixdev = -1;
 223         }
 224
 225     /* FIXME: only one device is supported */
 226     memset(&WOutDev[0].caps, 0, sizeof(WOutDev[0].caps));
 227
 228
 229
 230     /* FIXME: some programs compare this string against the content of the registry
 231      * for MM drivers. The names have to match in order for the program to work
 232      * (e.g. MS win9x mplayer.exe)
 233      */
 234 #ifdef EMULATE_SB16
 235     WOutDev[0].caps.wMid = 0x0002;
 236     WOutDev[0].caps.wPid = 0x0104;
 237     strcpy(WOutDev[0].caps.szPname, "SB16 Wave Out");
 238 #else
 239     WOutDev[0].caps.wMid = 0x00FF;      /* Manufac ID */
 240     WOutDev[0].caps.wPid = 0x0001;      /* Product ID */
 241     /*    strcpy(WOutDev[0].caps.szPname, "OpenSoundSystem WAVOUT Driver");*/
 242     strcpy(WOutDev[0].caps.szPname, "CS4236/37/38");
 243 #endif
 244     WOutDev[0].caps.vDriverVersion = 0x0100;
 245     WOutDev[0].caps.dwFormats = 0x00000000;
 246     WOutDev[0].caps.dwSupport = WAVECAPS_VOLUME;
 247
 248     /*
 249      * Libaudioio works differently, you tell it what spec audio you want to write and it
 250      * Guarantees to match it by converting to the final format on the fly
 251      *So we dont need to read  back and compare
 252      */
 253
 254     bytespersmpl = spec[PLAYBACK].precision/8;
 255
 256     WOutDev[0].caps.wChannels = spec[PLAYBACK].channels;
 257
 258
 259 /* Fixme: Libaudioio 0.2 doesn't support balance yet (Libaudioio 0.3 does so this must be fixed later)*/
 260
 261 /*    if (WOutDev[0].caps.wChannels > 1) WOutDev[0].caps.dwSupport |= WAVECAPS_LRVOLUME;*/
 262     TRACE("Init sammplerate= %d\n",spec[PLAYBACK].rate);
 263
 264     smplrate = spec[PLAYBACK].rate;
 265 /*
 266  * We have set up the data format to be 16 bit signed in intel format
 267  * For Big Endian machines libaudioio will convert the data to bigendian for us
 268  */
 269
 270             WOutDev[0].caps.dwFormats |= WAVE_FORMAT_4M16;
 271             if (WOutDev[0].caps.wChannels > 1)
 272                 WOutDev[0].caps.dwFormats |= WAVE_FORMAT_4S16;
 273
 274 /* Don't understand this yet, but I dont think this functionality is portable, leave here for future evaluation
 275  *   if (IOCTL(audio, SNDCTL_DSP_GETCAPS, caps) == 0) {
 276  *      TRACE("OSS dsp out caps=%08X\n", caps);
 277  *      if ((caps & DSP_CAP_REALTIME) && !(caps & DSP_CAP_BATCH)) {
 278  *          WOutDev[0].caps.dwSupport |= WAVECAPS_SAMPLEACCURATE;
 279  *      }
 280  */     /* well, might as well use the DirectSound cap flag for something */
 281 /*      if ((caps & DSP_CAP_TRIGGER) && (caps & DSP_CAP_MMAP) &&
 282  *          !(caps & DSP_CAP_BATCH))
 283  *          WOutDev[0].caps.dwSupport |= WAVECAPS_DIRECTSOUND;
 284  *   }
 285  */
 286
 287
 288 /*
 289  * Note that libaudioio audio capture is not proven yet, in our open call
 290  * set the spec for input audio the same as for output
 291  */
 292     TRACE("out dwFormats = %08lX, dwSupport = %08lX\n",
 293           WOutDev[0].caps.dwFormats, WOutDev[0].caps.dwSupport);
 294
 295         for (i = 0; i < MAX_WAVEINDRV; ++i)
 296         {
 297                 WInDev[i].unixdev = -1;
 298         }
 299
 300         memset(&WInDev[0].caps, 0, sizeof(WInDev[0].caps));
 301
 302
 303
 304 #ifdef EMULATE_SB16
 305     WInDev[0].caps.wMid = 0x0002;
 306     WInDev[0].caps.wPid = 0x0004;
 307     strcpy(WInDev[0].caps.szPname, "SB16 Wave In");
 308 #else
 309     WInDev[0].caps.wMid = 0x00FF;       /* Manufac ID */
 310     WInDev[0].caps.wPid = 0x0001;       /* Product ID */
 311     strcpy(WInDev[0].caps.szPname, "OpenSoundSystem WAVIN Driver");
 312 #endif
 313     WInDev[0].caps.dwFormats = 0x00000000;
 314     WInDev[0].caps.wChannels = spec[RECORD].channels;
 315
 316     WInDev[0].bTriggerSupport = TRUE;    /* Maybe :-) */
 317
 318     bytespersmpl = spec[RECORD].precision/8;
 319     smplrate = spec[RECORD].rate;
 320
 321             WInDev[0].caps.dwFormats |= WAVE_FORMAT_4M16;
 322             if (WInDev[0].caps.wChannels > 1)
 323                 WInDev[0].caps.dwFormats |= WAVE_FORMAT_4S16;
 324
 325
 326     TRACE("in dwFormats = %08lX\n", WInDev[0].caps.dwFormats);
 327
 328     return 0;
 329 }
 330
 331 /**************************************************************************
 332  *                      LIBAUDIOIO_NotifyClient                 [internal]
 333  */
 334 static DWORD LIBAUDIOIO_NotifyClient(UINT wDevID, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
 335 {
 336     TRACE("wDevID = %04X wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n",wDevID, wMsg, dwParam1, dwParam2);
 337
 338     switch (wMsg) {
 339     case WOM_OPEN:
 340     case WOM_CLOSE:
 341     case WOM_DONE:
 342         if (wDevID >= MAX_WAVEOUTDRV) return MCIERR_INTERNAL;
 343
 344         if (WOutDev[wDevID].wFlags != DCB_NULL &&
 345             !DriverCallback(WOutDev[wDevID].waveDesc.dwCallback,
 346                             WOutDev[wDevID].wFlags,
 347                             WOutDev[wDevID].waveDesc.hWave,
 348                             wMsg,
 349                             WOutDev[wDevID].waveDesc.dwInstance,
 350                             dwParam1,
 351                             dwParam2)) {
 352             WARN("can't notify client !\n");
 353             return MMSYSERR_NOERROR;
 354         }
 355         break;
 356
 357     case WIM_OPEN:
 358     case WIM_CLOSE:
 359     case WIM_DATA:
 360         if (wDevID >= MAX_WAVEINDRV) return MCIERR_INTERNAL;
 361
 362         if (WInDev[wDevID].wFlags != DCB_NULL &&
 363             !DriverCallback(WInDev[wDevID].waveDesc.dwCallback,
 364                             WInDev[wDevID].wFlags,
 365                             WInDev[wDevID].waveDesc.hWave,
 366                             wMsg,
 367                             WInDev[wDevID].waveDesc.dwInstance,
 368                             dwParam1,
 369                             dwParam2)) {
 370             WARN("can't notify client !\n");
 371             return MMSYSERR_NOERROR;
 372         }
 373         break;
 374     default:
 375         FIXME("Unknown CB message %u\n", wMsg);
 376         break;
 377     }
 378     return 0;
 379 }
 380
 381 /*======================================================================*
 382  *                  Low level WAVE OUT implementation                   *
 383  *======================================================================*/
 384
 385 /**************************************************************************
 386  *                              wodPlayer_WriteFragments        [internal]
 387  *
 388  * wodPlayer helper. Writes as many fragments as it can to unixdev.
 389  * Returns TRUE in case of buffer underrun.
 390  */
 391 static  BOOL    wodPlayer_WriteFragments(WINE_WAVEOUT* wwo)
 392 {
 393     LPWAVEHDR           lpWaveHdr;
 394     LPBYTE              lpData;
 395     int                 count;
 396
 397 TRACE("wodPlayer_WriteFragments sammplerate= %d\n",spec[PLAYBACK].rate);
 398     for (;;) {
 399
 400
 401 /*
 402  * Libaudioio doesn't buffer the same way as linux, you can write data is any block size
 403  *And libaudioio just tracks the number of blocks in the streams queue to control latency
 404  */
 405
 406         if (!AudioIOCheckWriteReady()) return FALSE;   /*  Returns false if you have execeeded your specified latency (No space left)*/
 407
 408         lpWaveHdr = wwo->lpPlayPtr;
 409         if (!lpWaveHdr) {
 410             if (wwo->dwRemain > 0 &&            /* still data to send to complete current fragment */
 411                 wwo->dwLastFragDone &&          /* first fragment has been played */
 412                 AudioIOCheckUnderrun()) {   /* done with all waveOutWrite()' fragments */
 413                 /* FIXME: should do better handling here */
 414                 WARN("Oooch, buffer underrun !\n");
 415                 return TRUE; /* force resetting of waveOut device */
 416             }
 417             return FALSE;       /* wait a bit */
 418         }
 419
 420         if (wwo->dwOffCurrHdr == 0) {
 421             TRACE("Starting a new wavehdr %p of %ld bytes\n", lpWaveHdr, lpWaveHdr->dwBufferLength);
 422             if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
 423                 if (wwo->lpLoopPtr) {
 424                     WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
 425                 } else {
 426                     TRACE("Starting loop (%ldx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
 427                     wwo->lpLoopPtr = lpWaveHdr;
 428                     /* Windows does not touch WAVEHDR.dwLoops,
 429                      * so we need to make an internal copy */
 430                     wwo->dwLoops = lpWaveHdr->dwLoops;
 431                 }
 432             }
 433         }
 434
 435         lpData = lpWaveHdr->lpData;
 436
 437         /* finish current wave hdr ? */
 438         if (wwo->dwOffCurrHdr + wwo->dwRemain >= lpWaveHdr->dwBufferLength) {
 439             DWORD       toWrite = lpWaveHdr->dwBufferLength - wwo->dwOffCurrHdr;
 440
 441             /* write end of current wave hdr */
 442             count = AudioIOWrite(lpData + wwo->dwOffCurrHdr, toWrite);
 443             TRACE("write(%p[%5lu], %5lu) => %d\n", lpData, wwo->dwOffCurrHdr, toWrite, count);
 444
 445             if (count > 0 || toWrite == 0) {
 446                 DWORD   tc = GetTickCount();
 447
 448                 if (wwo->dwLastFragDone /* + guard time ?? */ < tc)
 449                     wwo->dwLastFragDone = tc;
 450                 wwo->dwLastFragDone += (toWrite * 1000) / wwo->format.wf.nAvgBytesPerSec;
 451
 452                 lpWaveHdr->reserved = wwo->dwLastFragDone;
 453                 TRACE("Tagging hdr %p with %08lx\n", lpWaveHdr, wwo->dwLastFragDone);
 454
 455                 /* WAVEHDR written, go to next one */
 456                 if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
 457                     if (--wwo->dwLoops > 0) {
 458                         wwo->lpPlayPtr = wwo->lpLoopPtr;
 459                     } else {
 460                         /* last one played */
 461                         if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
 462                             FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
 463                             /* shall we consider the END flag for the closing loop or for
 464                              * the opening one or for both ???
 465                              * code assumes for closing loop only
 466                              */
 467                             wwo->lpLoopPtr = lpWaveHdr;
 468                         } else {
 469                             wwo->lpLoopPtr = NULL;
 470                         }
 471                         wwo->lpPlayPtr = lpWaveHdr->lpNext;
 472                     }
 473                 } else {
 474                     wwo->lpPlayPtr = lpWaveHdr->lpNext;
 475                 }
 476                 wwo->dwOffCurrHdr = 0;
 477                 if ((wwo->dwRemain -= count) == 0) {
 478                     wwo->dwRemain = wwo->dwFragmentSize;
 479                 }
 480             }
 481             continue; /* try to go to use next wavehdr */
 482         }  else {
 483             count = AudioIOWrite( lpData + wwo->dwOffCurrHdr, wwo->dwRemain);
 484             TRACE("write(%p[%5lu], %5lu) => %d\n", lpData, wwo->dwOffCurrHdr, wwo->dwRemain, count);
 485             if (count > 0) {
 486                 DWORD   tc = GetTickCount();
 487
 488                 if (wwo->dwLastFragDone /* + guard time ?? */ < tc)
 489                     wwo->dwLastFragDone = tc;
 490                 wwo->dwLastFragDone += (wwo->dwRemain * 1000) / wwo->format.wf.nAvgBytesPerSec;
 491
 492                 TRACE("Tagging frag with %08lx\n", wwo->dwLastFragDone);
 493
 494                 wwo->dwOffCurrHdr += count;
 495                 wwo->dwRemain = wwo->dwFragmentSize;
 496             }
 497         }
 498     }
 499
 500 }
 501
 502 int wodPlayer_Message(WINE_WAVEOUT *wwo, int msg, DWORD param)
 503 {
 504     TRACE("wodPlayerMessage sammplerate= %d  msg=%d\n",spec[PLAYBACK].rate,msg);
 505     EnterCriticalSection(&wwo->msg_crst);
 506     if ((wwo->msg_tosave == wwo->msg_toget) /* buffer overflow ? */
 507     &&  (wwo->messages[wwo->msg_toget].msg))
 508     {
 509         ERR("buffer overflow !?\n");
 510         LeaveCriticalSection(&wwo->msg_crst);
 511         return 0;
 512     }
 513
 514     wwo->messages[wwo->msg_tosave].msg = msg;
 515     wwo->messages[wwo->msg_tosave].param = param;
 516     wwo->msg_tosave++;
 517     if (wwo->msg_tosave > WWO_RING_BUFFER_SIZE-1)
 518         wwo->msg_tosave = 0;
 519     LeaveCriticalSection(&wwo->msg_crst);
 520     /* signal a new message */
 521     SetEvent(wwo->msg_event);
 522     return 1;
 523 }
 524
 525 int wodPlayer_RetrieveMessage(WINE_WAVEOUT *wwo, int *msg, DWORD *param)
 526 {
 527     EnterCriticalSection(&wwo->msg_crst);
 528
 529     if (wwo->msg_toget == wwo->msg_tosave) /* buffer empty ? */
 530     {
 531         LeaveCriticalSection(&wwo->msg_crst);
 532         return 0;
 533     }
 534
 535     *msg = wwo->messages[wwo->msg_toget].msg;
 536     wwo->messages[wwo->msg_toget].msg = 0;
 537     *param = wwo->messages[wwo->msg_toget].param;
 538     wwo->msg_toget++;
 539     if (wwo->msg_toget > WWO_RING_BUFFER_SIZE-1)
 540         wwo->msg_toget = 0;
 541     LeaveCriticalSection(&wwo->msg_crst);
 542     return 1;
 543 }
 544
 545 /**************************************************************************
 546  *                              wodPlayer_Notify                [internal]
 547  *
 548  * wodPlayer helper. Notifies (and remove from queue) all the wavehdr which content
 549  * have been played (actually to speaker, not to unixdev fd).
 550  */
 551 static  void    wodPlayer_Notify(WINE_WAVEOUT* wwo, WORD uDevID, BOOL force)
 552 {
 553     LPWAVEHDR           lpWaveHdr;
 554     DWORD               tc = GetTickCount();
 555
 556     while (wwo->lpQueuePtr &&
 557            (force ||
 558             (wwo->lpQueuePtr != wwo->lpPlayPtr && wwo->lpQueuePtr != wwo->lpLoopPtr))) {
 559         lpWaveHdr = wwo->lpQueuePtr;
 560
 561         if (lpWaveHdr->reserved > tc && !force) break;
 562
 563         wwo->dwPlayedTotal += lpWaveHdr->dwBufferLength;
 564         wwo->lpQueuePtr = lpWaveHdr->lpNext;
 565
 566         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
 567         lpWaveHdr->dwFlags |= WHDR_DONE;
 568
 569         TRACE("Notifying client with %p\n", lpWaveHdr);
 570         if (LIBAUDIOIO_NotifyClient(uDevID, WOM_DONE, (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR) {
 571             WARN("can't notify client !\n");
 572         }
 573     }
 574 }
 575
 576 /**************************************************************************
 577  *                              wodPlayer_Reset                 [internal]
 578  *
 579  * wodPlayer helper. Resets current output stream.
 580  */
 581 static  void    wodPlayer_Reset(WINE_WAVEOUT* wwo, WORD uDevID, BOOL reset)
 582 {
 583     /* updates current notify list */
 584     wodPlayer_Notify(wwo, uDevID, FALSE);
 585
 586     /* flush all possible output */
 587 /*
 588  *FIXME In the original code I think this aborted IO. With Libaudioio you have to wait
 589  * The following function just blocks untill I/O is complete
 590  * There is possibly a way to abort the blocks buffered in streams
 591  * but this approach seems to work OK
 592  */
 593         AudioIOFlush();
 594
 595
 596
 597     wwo->dwOffCurrHdr = 0;
 598     wwo->dwRemain = wwo->dwFragmentSize;
 599     if (reset) {
 600         /* empty notify list */
 601         wodPlayer_Notify(wwo, uDevID, TRUE);
 602
 603         wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
 604         wwo->state = WINE_WS_STOPPED;
 605         wwo->dwPlayedTotal = 0;
 606     } else {
 607         /* FIXME: this is not accurate when looping, but can be do better ? */
 608         wwo->lpPlayPtr = (wwo->lpLoopPtr) ? wwo->lpLoopPtr : wwo->lpQueuePtr;
 609         wwo->state = WINE_WS_PAUSED;
 610     }
 611 }
 612
 613 /**************************************************************************
 614  *                              wodPlayer                       [internal]
 615  */
 616 static  DWORD   CALLBACK        wodPlayer(LPVOID pmt)
 617 {
 618     WORD                uDevID = (DWORD)pmt;
 619     WINE_WAVEOUT*       wwo = (WINE_WAVEOUT*)&WOutDev[uDevID];
 620     WAVEHDR*            lpWaveHdr;
 621     DWORD               dwSleepTime;
 622     int                 msg;
 623     DWORD               param;
 624     DWORD               tc;
 625     BOOL                had_msg;
 626
 627     wwo->state = WINE_WS_STOPPED;
 628
 629     wwo->dwLastFragDone = 0;
 630     wwo->dwOffCurrHdr = 0;
 631     wwo->dwRemain = wwo->dwFragmentSize;
 632     wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
 633     wwo->dwPlayedTotal = 0;
 634
 635     TRACE("imhere[0]\n");
 636     SetEvent(wwo->hEvent);
 637
 638     for (;;) {
 639         /* wait for dwSleepTime or an event in thread's queue
 640          * FIXME:
 641          * - is wait time calculation optimal ?
 642          * - these 100 ms parts should be changed, but Eric reports
 643          *   that the wodPlayer thread might lock up if we use INFINITE
 644          *   (strange !), so I better don't change that now... */
 645         if (wwo->state != WINE_WS_PLAYING)
 646             dwSleepTime = 100;
 647         else
 648         {
 649             tc = GetTickCount();
 650             if (tc < wwo->dwLastFragDone)
 651             {
 652                 /* calculate sleep time depending on when the last fragment
 653                    will be played */
 654                 dwSleepTime = (wwo->dwLastFragDone - tc)*7/10;
 655                 if (dwSleepTime > 100)
 656                     dwSleepTime = 100;
 657             }
 658             else
 659                 dwSleepTime = 0;
 660         }
 661
 662         TRACE("imhere[1] tc = %08lx\n", GetTickCount());
 663         if (dwSleepTime)
 664             WaitForSingleObject(wwo->msg_event, dwSleepTime);
 665         TRACE("imhere[2] (q=%p p=%p) tc = %08lx\n", wwo->lpQueuePtr,
 666               wwo->lpPlayPtr, GetTickCount());
 667         had_msg = FALSE;
 668         while (wodPlayer_RetrieveMessage(wwo, &msg, &param)) {
 669             had_msg = TRUE;
 670             switch (msg) {
 671             case WINE_WM_PAUSING:
 672                 wodPlayer_Reset(wwo, uDevID, FALSE);
 673                 wwo->state = WINE_WS_PAUSED;
 674                 SetEvent(wwo->hEvent);
 675                 break;
 676             case WINE_WM_RESTARTING:
 677                 wwo->state = WINE_WS_PLAYING;
 678                 SetEvent(wwo->hEvent);
 679                 break;
 680             case WINE_WM_HEADER:
 681                 lpWaveHdr = (LPWAVEHDR)param;
 682
 683                 /* insert buffer at the end of queue */
 684                 {
 685                     LPWAVEHDR*  wh;
 686                     for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
 687                     *wh = lpWaveHdr;
 688                 }
 689                 if (!wwo->lpPlayPtr) wwo->lpPlayPtr = lpWaveHdr;
 690                 if (wwo->state == WINE_WS_STOPPED)
 691                     wwo->state = WINE_WS_PLAYING;
 692                 break;
 693             case WINE_WM_RESETTING:
 694                 wodPlayer_Reset(wwo, uDevID, TRUE);
 695                 SetEvent(wwo->hEvent);
 696                 break;
 697             case WINE_WM_CLOSING:
 698                 /* sanity check: this should not happen since the device must have been reset before */
 699                 if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
 700                 wwo->hThread = 0;
 701                 wwo->state = WINE_WS_CLOSED;
 702                 SetEvent(wwo->hEvent);
 703                 ExitThread(0);
 704                 /* shouldn't go here */
 705             default:
 706                 FIXME("unknown message %d\n", msg);
 707                 break;
 708             }
 709             if (wwo->state == WINE_WS_PLAYING) {
 710                 wodPlayer_WriteFragments(wwo);
 711             }
 712             wodPlayer_Notify(wwo, uDevID, FALSE);
 713         }
 714
 715         if (!had_msg) { /* if we've received a msg we've just done this so we
 716                            won't repeat it */
 717             if (wwo->state == WINE_WS_PLAYING) {
 718                 wodPlayer_WriteFragments(wwo);
 719             }
 720             wodPlayer_Notify(wwo, uDevID, FALSE);
 721         }
 722     }
 723     ExitThread(0);
 724     /* just for not generating compilation warnings... should never be executed */
 725     return 0;
 726 }
 727
 728 /**************************************************************************
 729  *                      wodGetDevCaps                           [internal]
 730  */
 731 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSA lpCaps, DWORD dwSize)
 732 {
 733     TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
 734
 735     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
 736
 737     if (wDevID >= MAX_WAVEOUTDRV) {
 738         TRACE("MAX_WAVOUTDRV reached !\n");
 739         return MMSYSERR_BADDEVICEID;
 740     }
 741
 742     memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
 743     return MMSYSERR_NOERROR;
 744 }
 745
 746 /**************************************************************************
 747  *                              wodOpen                         [internal]
 748  */
 749 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
 750 {
 751     int                 audio;
 752     int                 format;
 753     int                 sample_rate;
 754     int                 dsp_stereo;
 755     int                 fragment_size;
 756     int                 audio_fragment;
 757     WINE_WAVEOUT*       wwo;
 758
 759     TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
 760     if (lpDesc == NULL) {
 761         WARN("Invalid Parameter !\n");
 762         return MMSYSERR_INVALPARAM;
 763     }
 764     if (wDevID >= MAX_WAVEOUTDRV) {
 765         TRACE("MAX_WAVOUTDRV reached !\n");
 766         return MMSYSERR_BADDEVICEID;
 767     }
 768
 769     /* only PCM format is supported so far... */
 770     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
 771         lpDesc->lpFormat->nChannels == 0 ||
 772         lpDesc->lpFormat->nSamplesPerSec == 0) {
 773         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
 774              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
 775              lpDesc->lpFormat->nSamplesPerSec);
 776         return WAVERR_BADFORMAT;
 777     }
 778
 779     if (dwFlags & WAVE_FORMAT_QUERY) {
 780         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
 781              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
 782              lpDesc->lpFormat->nSamplesPerSec);
 783         return MMSYSERR_NOERROR;
 784     }
 785
 786     wwo = &WOutDev[wDevID];
 787
 788     if ((dwFlags & WAVE_DIRECTSOUND) && !(wwo->caps.dwSupport & WAVECAPS_DIRECTSOUND))
 789         /* not supported, ignore it */
 790         dwFlags &= ~WAVE_DIRECTSOUND;
 791
 792     if (access(SOUND_DEV, 0) != 0)
 793         return MMSYSERR_NOTENABLED;
 794
 795         audio = AudioIOOpenX( O_WRONLY|O_NDELAY,&spec[PLAYBACK],&spec[PLAYBACK]);
 796
 797     if (audio == -1) {
 798         WARN("can't open sound device %s (%s)!\n", SOUND_DEV, strerror(errno));
 799         return MMSYSERR_ALLOCATED;
 800     }
 801  /*   fcntl(audio, F_SETFD, 1); *//* set close on exec flag - Dunno about this (RL)*/
 802     wwo->unixdev = audio;
 803     wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 804
 805     memcpy(&wwo->waveDesc, lpDesc,           sizeof(WAVEOPENDESC));
 806     memcpy(&wwo->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
 807
 808     if (wwo->format.wBitsPerSample == 0) {
 809         WARN("Resetting zeroed wBitsPerSample\n");
 810         wwo->format.wBitsPerSample = 8 *
 811             (wwo->format.wf.nAvgBytesPerSec /
 812              wwo->format.wf.nSamplesPerSec) /
 813             wwo->format.wf.nChannels;
 814     }
 815
 816     if (dwFlags & WAVE_DIRECTSOUND) {
 817         if (wwo->caps.dwSupport & WAVECAPS_SAMPLEACCURATE)
 818             /* we have realtime DirectSound, fragments just waste our time,
 819              * but a large buffer is good, so choose 64KB (32 * 2^11) */
 820             audio_fragment = 0x0020000B;
 821         else
 822             /* to approximate realtime, we must use small fragments,
 823              * let's try to fragment the above 64KB (256 * 2^8) */
 824             audio_fragment = 0x01000008;
 825     } else {
 826         /* shockwave player uses only 4 1k-fragments at a rate of 22050 bytes/sec
 827          * thus leading to 46ms per fragment, and a turnaround time of 185ms
 828          */
 829         /* 16 fragments max, 2^10=1024 bytes per fragment */
 830         audio_fragment = 0x000F000A;
 831     }
 832     sample_rate = wwo->format.wf.nSamplesPerSec;
 833     dsp_stereo = (wwo->format.wf.nChannels > 1) ? 1 : 0;
 834
 835
 836
 837     /*Set the sample rate*/
 838     spec[PLAYBACK].rate=sample_rate;
 839
 840     /*And the size and signedness*/
 841     spec[PLAYBACK].precision=(wwo->format.wBitsPerSample );
 842     if (spec[PLAYBACK].precision==16) spec[PLAYBACK].type=TYPE_SIGNED; else spec[PLAYBACK].type=TYPE_UNSIGNED;
 843     spec[PLAYBACK].channels=(wwo->format.wf.nChannels);
 844     spec[PLAYBACK].encoding=ENCODE_PCM;
 845     spec[PLAYBACK].endian=ENDIAN_INTEL;
 846     spec[PLAYBACK].max_blocks=16;  /*FIXME This is the libaudioio equivalent to fragments, it controls latency*/
 847
 848         audio = AudioIOOpenX( O_WRONLY|O_NDELAY,&spec[PLAYBACK],&spec[PLAYBACK]);
 849
 850     if (audio == -1) {
 851         WARN("can't open sound device %s (%s)!\n", SOUND_DEV, strerror(errno));
 852         return MMSYSERR_ALLOCATED;
 853     }
 854  /*   fcntl(audio, F_SETFD, 1); *//* set close on exec flag */
 855     wwo->unixdev = audio;
 856
 857
 858     /* even if we set fragment size above, read it again, just in case */
 859
 860     wwo->dwFragmentSize = DEFAULT_FRAGMENT_SIZE;
 861
 862     wwo->msg_toget = 0;
 863     wwo->msg_tosave = 0;
 864     wwo->msg_event = CreateEventA(NULL, FALSE, FALSE, NULL);
 865     memset(wwo->messages, 0, sizeof(WWO_MSG)*WWO_RING_BUFFER_SIZE);
 866     InitializeCriticalSection(&wwo->msg_crst);
 867
 868     if (!(dwFlags & WAVE_DIRECTSOUND)) {
 869         wwo->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
 870         wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD)wDevID, 0, &(wwo->dwThreadID));
 871         WaitForSingleObject(wwo->hEvent, INFINITE);
 872     } else {
 873         wwo->hEvent = INVALID_HANDLE_VALUE;
 874         wwo->hThread = INVALID_HANDLE_VALUE;
 875         wwo->dwThreadID = 0;
 876     }
 877
 878     TRACE("fd=%d fragmentSize=%ld\n",
 879           wwo->unixdev, wwo->dwFragmentSize);
 880     if (wwo->dwFragmentSize % wwo->format.wf.nBlockAlign)
 881         ERR("Fragment doesn't contain an integral number of data blocks\n");
 882
 883     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n",
 884           wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec,
 885           wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
 886           wwo->format.wf.nBlockAlign);
 887
 888     if (LIBAUDIOIO_NotifyClient(wDevID, WOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
 889         WARN("can't notify client !\n");
 890         return MMSYSERR_INVALPARAM;
 891     }
 892     return MMSYSERR_NOERROR;
 893 }
 894
 895 /**************************************************************************
 896  *                              wodClose                        [internal]
 897  */
 898 static DWORD wodClose(WORD wDevID)
 899 {
 900     DWORD               ret = MMSYSERR_NOERROR;
 901     WINE_WAVEOUT*       wwo;
 902
 903     TRACE("(%u);\n", wDevID);
 904
 905     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].unixdev == -1) {
 906         WARN("bad device ID !\n");
 907         return MMSYSERR_BADDEVICEID;
 908     }
 909
 910     wwo = &WOutDev[wDevID];
 911     if (wwo->lpQueuePtr) {
 912         WARN("buffers still playing !\n");
 913         ret = WAVERR_STILLPLAYING;
 914     } else {
 915         TRACE("imhere[3-close]\n");
 916         if (wwo->hEvent != INVALID_HANDLE_VALUE) {
 917             wodPlayer_Message(wwo, WINE_WM_CLOSING, 0);
 918             WaitForSingleObject(wwo->hEvent, INFINITE);
 919             CloseHandle(wwo->hEvent);
 920         }
 921         if (wwo->mapping) {
 922             munmap(wwo->mapping, wwo->maplen);
 923             wwo->mapping = NULL;
 924         }
 925
 926         AudioIOClose();
 927         wwo->unixdev = -1;
 928         wwo->dwFragmentSize = 0;
 929         if (LIBAUDIOIO_NotifyClient(wDevID, WOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
 930             WARN("can't notify client !\n");
 931             ret = MMSYSERR_INVALPARAM;
 932         }
 933     }
 934     return ret;
 935 }
 936
 937 /**************************************************************************
 938  *                              wodWrite                        [internal]
 939  *
 940  */
 941 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
 942 {
 943     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
 944
 945     /* first, do the sanity checks... */
 946     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].unixdev == -1) {
 947         WARN("bad dev ID !\n");
 948         return MMSYSERR_BADDEVICEID;
 949     }
 950
 951     if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
 952         return WAVERR_UNPREPARED;
 953
 954     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
 955         return WAVERR_STILLPLAYING;
 956
 957     lpWaveHdr->dwFlags &= ~WHDR_DONE;
 958     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
 959     lpWaveHdr->lpNext = 0;
 960
 961     TRACE("imhere[3-HEADER]\n");
 962     wodPlayer_Message(&WOutDev[wDevID], WINE_WM_HEADER, (DWORD)lpWaveHdr);
 963
 964     return MMSYSERR_NOERROR;
 965 }
 966
 967 /**************************************************************************
 968  *                              wodPrepare                      [internal]
 969  */
 970 static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
 971 {
 972     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
 973
 974     if (wDevID >= MAX_WAVEOUTDRV) {
 975         WARN("bad device ID !\n");
 976         return MMSYSERR_BADDEVICEID;
 977     }
 978
 979     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
 980         return WAVERR_STILLPLAYING;
 981
 982     lpWaveHdr->dwFlags |= WHDR_PREPARED;
 983     lpWaveHdr->dwFlags &= ~WHDR_DONE;
 984     return MMSYSERR_NOERROR;
 985 }
 986
 987 /**************************************************************************
 988  *                              wodUnprepare                    [internal]
 989  */
 990 static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
 991 {
 992     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
 993
 994     if (wDevID >= MAX_WAVEOUTDRV) {
 995         WARN("bad device ID !\n");
 996         return MMSYSERR_BADDEVICEID;
 997     }
 998
 999     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1000         return WAVERR_STILLPLAYING;
1001
1002     lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
1003     lpWaveHdr->dwFlags |= WHDR_DONE;
1004
1005     return MMSYSERR_NOERROR;
1006 }
1007
1008 /**************************************************************************
1009  *                      wodPause                                [internal]
1010  */
1011 static DWORD wodPause(WORD wDevID)
1012 {
1013     TRACE("(%u);!\n", wDevID);
1014
1015     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].unixdev == -1) {
1016         WARN("bad device ID !\n");
1017         return MMSYSERR_BADDEVICEID;
1018     }
1019
1020     TRACE("imhere[3-PAUSING]\n");
1021     wodPlayer_Message(&WOutDev[wDevID], WINE_WM_PAUSING, 0);
1022     WaitForSingleObject(WOutDev[wDevID].hEvent, INFINITE);
1023
1024     return MMSYSERR_NOERROR;
1025 }
1026
1027 /**************************************************************************
1028  *                      wodRestart                              [internal]
1029  */
1030 static DWORD wodRestart(WORD wDevID)
1031 {
1032     TRACE("(%u);\n", wDevID);
1033
1034     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].unixdev == -1) {
1035         WARN("bad device ID !\n");
1036         return MMSYSERR_BADDEVICEID;
1037     }
1038
1039     if (WOutDev[wDevID].state == WINE_WS_PAUSED) {
1040         TRACE("imhere[3-RESTARTING]\n");
1041         wodPlayer_Message(&WOutDev[wDevID], WINE_WM_RESTARTING, 0);
1042         WaitForSingleObject(WOutDev[wDevID].hEvent, INFINITE);
1043     }
1044
1045     /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
1046     /* FIXME: Myst crashes with this ... hmm -MM
1047        if (LIBAUDIOIO_NotifyClient(wDevID, WOM_DONE, 0L, 0L) != MMSYSERR_NOERROR) {
1048        WARN("can't notify client !\n");
1049        return MMSYSERR_INVALPARAM;
1050        }
1051     */
1052
1053     return MMSYSERR_NOERROR;
1054 }
1055
1056 /**************************************************************************
1057  *                      wodReset                                [internal]
1058  */
1059 static DWORD wodReset(WORD wDevID)
1060 {
1061     TRACE("(%u);\n", wDevID);
1062
1063     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].unixdev == -1) {
1064         WARN("bad device ID !\n");
1065         return MMSYSERR_BADDEVICEID;
1066     }
1067
1068     TRACE("imhere[3-RESET]\n");
1069     wodPlayer_Message(&WOutDev[wDevID], WINE_WM_RESETTING, 0);
1070     WaitForSingleObject(WOutDev[wDevID].hEvent, INFINITE);
1071
1072     return MMSYSERR_NOERROR;
1073 }
1074
1075
1076 /**************************************************************************
1077  *                              wodGetPosition                  [internal]
1078  */
1079 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1080 {
1081     int                 time;
1082     DWORD               val;
1083     WINE_WAVEOUT*       wwo;
1084
1085     TRACE("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
1086
1087     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].unixdev == -1) {
1088         WARN("bad device ID !\n");
1089         return MMSYSERR_BADDEVICEID;
1090     }
1091
1092     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1093
1094     wwo = &WOutDev[wDevID];
1095     val = wwo->dwPlayedTotal;
1096
1097     TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%lu nChannels=%u nAvgBytesPerSec=%lu\n",
1098           lpTime->wType, wwo->format.wBitsPerSample,
1099           wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1100           wwo->format.wf.nAvgBytesPerSec);
1101     TRACE("dwTotalPlayed=%lu\n", val);
1102
1103     switch (lpTime->wType) {
1104     case TIME_BYTES:
1105         lpTime->u.cb = val;
1106         TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
1107         break;
1108     case TIME_SAMPLES:
1109         lpTime->u.sample = val * 8 / wwo->format.wBitsPerSample;
1110         TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
1111         break;
1112     case TIME_SMPTE:
1113         time = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
1114         lpTime->u.smpte.hour = time / 108000;
1115         time -= lpTime->u.smpte.hour * 108000;
1116         lpTime->u.smpte.min = time / 1800;
1117         time -= lpTime->u.smpte.min * 1800;
1118         lpTime->u.smpte.sec = time / 30;
1119         time -= lpTime->u.smpte.sec * 30;
1120         lpTime->u.smpte.frame = time;
1121         lpTime->u.smpte.fps = 30;
1122         TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
1123               lpTime->u.smpte.hour, lpTime->u.smpte.min,
1124               lpTime->u.smpte.sec, lpTime->u.smpte.frame);
1125         break;
1126     default:
1127         FIXME("Format %d not supported ! use TIME_MS !\n", lpTime->wType);
1128         lpTime->wType = TIME_MS;
1129     case TIME_MS:
1130         lpTime->u.ms = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
1131         TRACE("TIME_MS=%lu\n", lpTime->u.ms);
1132         break;
1133     }
1134     return MMSYSERR_NOERROR;
1135 }
1136
1137 /**************************************************************************
1138  *                              wodGetVolume                    [internal]
1139  */
1140 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1141 {
1142     int         mixer;
1143     int         vol,bal;
1144     DWORD       left, right;
1145
1146     TRACE("(%u, %p);\n", wDevID, lpdwVol);
1147
1148     if (lpdwVol == NULL)
1149         return MMSYSERR_NOTENABLED;
1150
1151      vol=AudioIOGetPlaybackVolume();
1152      bal=AudioIOGetPlaybackBalance();
1153
1154
1155      if(bal<0) {
1156         left = vol;
1157         right=-(vol*(-100+bal)/100);
1158      }
1159       else
1160      {
1161         right = vol;
1162         left=(vol*(100-bal)/100);
1163      }
1164
1165     *lpdwVol = ((left * 0xFFFFl) / 100) + (((right * 0xFFFFl) / 100) << 16);
1166     return MMSYSERR_NOERROR;
1167 }
1168
1169
1170 /**************************************************************************
1171  *                              wodSetVolume                    [internal]
1172  */
1173 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1174 {
1175     int         mixer;
1176     int         volume,bal;
1177     DWORD       left, right;
1178
1179     TRACE("(%u, %08lX);\n", wDevID, dwParam);
1180
1181     left  = (LOWORD(dwParam) * 100) / 0xFFFFl;
1182     right = (HIWORD(dwParam) * 100) / 0xFFFFl;
1183     volume = max(left , right );
1184     bal=min(left,right);
1185     bal=bal*100/volume;
1186     if(right>left) bal=-100+bal; else bal=100-bal;
1187
1188     AudioIOSetPlaybackVolume(volume);
1189     AudioIOSetPlaybackBalance(bal);
1190
1191     return MMSYSERR_NOERROR;
1192 }
1193
1194 /**************************************************************************
1195  *                              wodGetNumDevs                   [internal]
1196  */
1197 static  DWORD   wodGetNumDevs(void)
1198 {
1199     DWORD       ret = 1;
1200
1201     /* FIXME: For now, only one sound device (SOUND_DEV) is allowed */
1202     int audio = open(SOUND_DEV, O_WRONLY|O_NDELAY, 0);
1203
1204     if (audio == -1) {
1205         if (errno != EBUSY)
1206             ret = 0;
1207     } else {
1208         close(audio);
1209
1210     }
1211     TRACE("NumDrivers = %d\n",ret);
1212     return ret;
1213 }
1214
1215 /**************************************************************************
1216  *                              wodMessage (WINEAUDIOIO.@)
1217  */
1218 DWORD WINAPI LIBAUDIOIO_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1219                             DWORD dwParam1, DWORD dwParam2)
1220 {
1221     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
1222           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1223
1224     switch (wMsg) {
1225     case DRVM_INIT:
1226     case DRVM_EXIT:
1227     case DRVM_ENABLE:
1228     case DRVM_DISABLE:
1229         /* FIXME: Pretend this is supported */
1230         return 0;
1231     case WODM_OPEN:             return wodOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,      dwParam2);
1232     case WODM_CLOSE:            return wodClose         (wDevID);
1233     case WODM_WRITE:            return wodWrite         (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1234     case WODM_PAUSE:            return wodPause         (wDevID);
1235     case WODM_GETPOS:           return wodGetPosition   (wDevID, (LPMMTIME)dwParam1,            dwParam2);
1236     case WODM_BREAKLOOP:        return MMSYSERR_NOTSUPPORTED;
1237     case WODM_PREPARE:          return wodPrepare       (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1238     case WODM_UNPREPARE:        return wodUnprepare     (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1239     case WODM_GETDEVCAPS:       return wodGetDevCaps    (wDevID, (LPWAVEOUTCAPSA)dwParam1,      dwParam2);
1240     case WODM_GETNUMDEVS:       return wodGetNumDevs    ();
1241     case WODM_GETPITCH:         return MMSYSERR_NOTSUPPORTED;
1242     case WODM_SETPITCH:         return MMSYSERR_NOTSUPPORTED;
1243     case WODM_GETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1244     case WODM_SETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1245     case WODM_GETVOLUME:        return wodGetVolume     (wDevID, (LPDWORD)dwParam1);
1246     case WODM_SETVOLUME:        return wodSetVolume     (wDevID, dwParam1);
1247     case WODM_RESTART:          return wodRestart       (wDevID);
1248     case WODM_RESET:            return wodReset         (wDevID);
1249
1250     case DRV_QUERYDSOUNDIFACE:  return wodDsCreate      (wDevID, (PIDSDRIVER*)dwParam1);
1251     case DRV_QUERYDSOUNDDESC:   return wodDsDesc        (wDevID, (PDSDRIVERDESC)dwParam1);
1252     case DRV_QUERYDSOUNDGUID:   return wodDsGuid        (wDevID, (LPGUID)dwParam1);
1253     default:
1254         FIXME("unknown message %d!\n", wMsg);
1255     }
1256     return MMSYSERR_NOTSUPPORTED;
1257 }
1258
1259 /*======================================================================*
1260  *                  Low level DSOUND implementation                     *
1261  *              While I have tampered somewhat with this code it is wholely unlikely that it works
1262  *              Elsewhere the driver returns Not Implemented for DIrectSound
1263  *              While it may be possible to map the sound device on Solaris
1264  *              Doing so would bypass the libaudioio library and therefore break any conversions
1265  *              that the libaudioio sample specification converter is doing
1266  *              **** All this is untested so far
1267  *======================================================================*/
1268
1269 typedef struct IDsDriverImpl IDsDriverImpl;
1270 typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
1271
1272 struct IDsDriverImpl
1273 {
1274     /* IUnknown fields */
1275     ICOM_VFIELD(IDsDriver);
1276     DWORD               ref;
1277     /* IDsDriverImpl fields */
1278     UINT                wDevID;
1279     IDsDriverBufferImpl*primary;
1280 };
1281
1282 struct IDsDriverBufferImpl
1283 {
1284     /* IUnknown fields */
1285     ICOM_VFIELD(IDsDriverBuffer);
1286     DWORD               ref;
1287     /* IDsDriverBufferImpl fields */
1288     IDsDriverImpl*      drv;
1289     DWORD               buflen;
1290 };
1291
1292 static HRESULT DSDB_MapPrimary(IDsDriverBufferImpl *dsdb)
1293 {
1294     WINE_WAVEOUT *wwo = &(WOutDev[dsdb->drv->wDevID]);
1295     if (!wwo->mapping) {
1296         wwo->mapping = mmap(NULL, wwo->maplen, PROT_WRITE, MAP_SHARED,
1297                             wwo->unixdev, 0);
1298         if (wwo->mapping == (LPBYTE)-1) {
1299             ERR("(%p): Could not map sound device for direct access (errno=%d)\n", dsdb, errno);
1300             return DSERR_GENERIC;
1301         }
1302         TRACE("(%p): sound device has been mapped for direct access at %p, size=%ld\n", dsdb, wwo->mapping, wwo->maplen);
1303
1304         /* for some reason, es1371 and sblive! sometimes have junk in here. */
1305         memset(wwo->mapping,0,wwo->maplen); /* clear it, or we get junk noise */
1306     }
1307     return DS_OK;
1308 }
1309
1310 static HRESULT DSDB_UnmapPrimary(IDsDriverBufferImpl *dsdb)
1311 {
1312     WINE_WAVEOUT *wwo = &(WOutDev[dsdb->drv->wDevID]);
1313     if (wwo->mapping) {
1314         if (munmap(wwo->mapping, wwo->maplen) < 0) {
1315             ERR("(%p): Could not unmap sound device (errno=%d)\n", dsdb, errno);
1316             return DSERR_GENERIC;
1317         }
1318         wwo->mapping = NULL;
1319         TRACE("(%p): sound device unmapped\n", dsdb);
1320     }
1321     return DS_OK;
1322 }
1323
1324 static HRESULT WINAPI IDsDriverBufferImpl_QueryInterface(PIDSDRIVERBUFFER iface, REFIID riid, LPVOID *ppobj)
1325 {
1326     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1327     FIXME("(): stub!\n");
1328     return DSERR_UNSUPPORTED;
1329 }
1330
1331 static ULONG WINAPI IDsDriverBufferImpl_AddRef(PIDSDRIVERBUFFER iface)
1332 {
1333     ICOM_THIS(IDsDriverBufferImpl,iface);
1334     This->ref++;
1335     return This->ref;
1336 }
1337
1338 static ULONG WINAPI IDsDriverBufferImpl_Release(PIDSDRIVERBUFFER iface)
1339 {
1340     ICOM_THIS(IDsDriverBufferImpl,iface);
1341     if (--This->ref)
1342         return This->ref;
1343     if (This == This->drv->primary)
1344         This->drv->primary = NULL;
1345     DSDB_UnmapPrimary(This);
1346     HeapFree(GetProcessHeap(),0,This);
1347     return 0;
1348 }
1349
1350 static HRESULT WINAPI IDsDriverBufferImpl_Lock(PIDSDRIVERBUFFER iface,
1351                                                LPVOID*ppvAudio1,LPDWORD pdwLen1,
1352                                                LPVOID*ppvAudio2,LPDWORD pdwLen2,
1353                                                DWORD dwWritePosition,DWORD dwWriteLen,
1354                                                DWORD dwFlags)
1355 {
1356     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1357     /* since we (GetDriverDesc flags) have specified DSDDESC_DONTNEEDPRIMARYLOCK,
1358      * and that we don't support secondary buffers, this method will never be called */
1359     TRACE("(%p): stub\n",iface);
1360     return DSERR_UNSUPPORTED;
1361 }
1362
1363 static HRESULT WINAPI IDsDriverBufferImpl_Unlock(PIDSDRIVERBUFFER iface,
1364                                                  LPVOID pvAudio1,DWORD dwLen1,
1365                                                  LPVOID pvAudio2,DWORD dwLen2)
1366 {
1367     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1368     TRACE("(%p): stub\n",iface);
1369     return DSERR_UNSUPPORTED;
1370 }
1371
1372 static HRESULT WINAPI IDsDriverBufferImpl_SetFormat(PIDSDRIVERBUFFER iface,
1373                                                     LPWAVEFORMATEX pwfx)
1374 {
1375     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1376
1377     TRACE("(%p,%p)\n",iface,pwfx);
1378     /* On our request (GetDriverDesc flags), DirectSound has by now used
1379      * waveOutClose/waveOutOpen to set the format...
1380      * unfortunately, this means our mmap() is now gone...
1381      * so we need to somehow signal to our DirectSound implementation
1382      * that it should completely recreate this HW buffer...
1383      * this unexpected error code should do the trick... */
1384     return DSERR_BUFFERLOST;
1385 }
1386
1387 static HRESULT WINAPI IDsDriverBufferImpl_SetFrequency(PIDSDRIVERBUFFER iface, DWORD dwFreq)
1388 {
1389     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1390     TRACE("(%p,%ld): stub\n",iface,dwFreq);
1391     return DSERR_UNSUPPORTED;
1392 }
1393
1394 static HRESULT WINAPI IDsDriverBufferImpl_SetVolumePan(PIDSDRIVERBUFFER iface, PDSVOLUMEPAN pVolPan)
1395 {
1396     /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1397     FIXME("(%p,%p): stub!\n",iface,pVolPan);
1398     return DSERR_UNSUPPORTED;
1399 }
1400
1401 static HRESULT WINAPI IDsDriverBufferImpl_SetPosition(PIDSDRIVERBUFFER iface, DWORD dwNewPos)
1402 {
1403     /* ICOM_THIS(IDsDriverImpl,iface); */
1404     TRACE("(%p,%ld): stub\n",iface,dwNewPos);
1405     return DSERR_UNSUPPORTED;
1406 }
1407
1408 static HRESULT WINAPI IDsDriverBufferImpl_GetPosition(PIDSDRIVERBUFFER iface,
1409                                                       LPDWORD lpdwPlay, LPDWORD lpdwWrite)
1410 {
1411     ICOM_THIS(IDsDriverBufferImpl,iface);
1412 #if 0
1413     count_info info;
1414 #endif
1415     DWORD ptr;
1416
1417     TRACE("(%p)\n",iface);
1418     if (WOutDev[This->drv->wDevID].unixdev == -1) {
1419         ERR("device not open, but accessing?\n");
1420         return DSERR_UNINITIALIZED;
1421     }
1422     /*Libaudioio doesn't support this (Yet anyway)*/
1423      return DSERR_UNSUPPORTED;
1424
1425 }
1426
1427 static HRESULT WINAPI IDsDriverBufferImpl_Play(PIDSDRIVERBUFFER iface, DWORD dwRes1, DWORD dwRes2, DWORD dwFlags)
1428 {
1429     ICOM_THIS(IDsDriverBufferImpl,iface);
1430 #if 0
1431     int enable = PCM_ENABLE_OUTPUT;
1432     TRACE("(%p,%lx,%lx,%lx)\n",iface,dwRes1,dwRes2,dwFlags);
1433     if (ioctl(WOutDev[This->drv->wDevID].unixdev, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
1434         ERR("ioctl failed (%d)\n", errno);
1435         return DSERR_GENERIC;
1436     }
1437 #endif
1438     return DS_OK;
1439 }
1440
1441 static HRESULT WINAPI IDsDriverBufferImpl_Stop(PIDSDRIVERBUFFER iface)
1442 {
1443     ICOM_THIS(IDsDriverBufferImpl,iface);
1444     int enable = 0;
1445 #if 0
1446     TRACE("(%p)\n",iface);
1447     /* no more playing */
1448     if (ioctl(WOutDev[This->drv->wDevID].unixdev, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
1449         ERR("ioctl failed (%d)\n", errno);
1450         return DSERR_GENERIC;
1451     }
1452 #endif
1453 #if 0
1454     /* the play position must be reset to the beginning of the buffer */
1455     if (ioctl(WOutDev[This->drv->wDevID].unixdev, SNDCTL_DSP_RESET, 0) < 0) {
1456         ERR("ioctl failed (%d)\n", errno);
1457         return DSERR_GENERIC;
1458     }
1459 #endif
1460     /* Most OSS drivers just can't stop the playback without closing the device...
1461      * so we need to somehow signal to our DirectSound implementation
1462      * that it should completely recreate this HW buffer...
1463      * this unexpected error code should do the trick... */
1464     return DSERR_BUFFERLOST;
1465 }
1466
1467 static ICOM_VTABLE(IDsDriverBuffer) dsdbvt =
1468 {
1469     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1470     IDsDriverBufferImpl_QueryInterface,
1471     IDsDriverBufferImpl_AddRef,
1472     IDsDriverBufferImpl_Release,
1473     IDsDriverBufferImpl_Lock,
1474     IDsDriverBufferImpl_Unlock,
1475     IDsDriverBufferImpl_SetFormat,
1476     IDsDriverBufferImpl_SetFrequency,
1477     IDsDriverBufferImpl_SetVolumePan,
1478     IDsDriverBufferImpl_SetPosition,
1479     IDsDriverBufferImpl_GetPosition,
1480     IDsDriverBufferImpl_Play,
1481     IDsDriverBufferImpl_Stop
1482 };
1483
1484 static HRESULT WINAPI IDsDriverImpl_QueryInterface(PIDSDRIVER iface, REFIID riid, LPVOID *ppobj)
1485 {
1486     /* ICOM_THIS(IDsDriverImpl,iface); */
1487     FIXME("(%p): stub!\n",iface);
1488     return DSERR_UNSUPPORTED;
1489 }
1490
1491 static ULONG WINAPI IDsDriverImpl_AddRef(PIDSDRIVER iface)
1492 {
1493     ICOM_THIS(IDsDriverImpl,iface);
1494     This->ref++;
1495     return This->ref;
1496 }
1497
1498 static ULONG WINAPI IDsDriverImpl_Release(PIDSDRIVER iface)
1499 {
1500     ICOM_THIS(IDsDriverImpl,iface);
1501     if (--This->ref)
1502         return This->ref;
1503     HeapFree(GetProcessHeap(),0,This);
1504     return 0;
1505 }
1506
1507 static HRESULT WINAPI IDsDriverImpl_GetDriverDesc(PIDSDRIVER iface, PDSDRIVERDESC pDesc)
1508 {
1509     ICOM_THIS(IDsDriverImpl,iface);
1510     TRACE("(%p,%p)\n",iface,pDesc);
1511     pDesc->dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT |
1512         DSDDESC_USESYSTEMMEMORY | DSDDESC_DONTNEEDPRIMARYLOCK;
1513     strcpy(pDesc->szDesc,"Wine AudioIO DirectSound Driver");
1514     strcpy(pDesc->szDrvName,"wineaudioio.drv");
1515     pDesc->dnDevNode            = WOutDev[This->wDevID].waveDesc.dnDevNode;
1516     pDesc->wVxdId               = 0;
1517     pDesc->wReserved            = 0;
1518     pDesc->ulDeviceNum          = This->wDevID;
1519     pDesc->dwHeapType           = DSDHEAP_NOHEAP;
1520     pDesc->pvDirectDrawHeap     = NULL;
1521     pDesc->dwMemStartAddress    = 0;
1522     pDesc->dwMemEndAddress      = 0;
1523     pDesc->dwMemAllocExtra      = 0;
1524     pDesc->pvReserved1          = NULL;
1525     pDesc->pvReserved2          = NULL;
1526     return DS_OK;
1527 }
1528
1529 static HRESULT WINAPI IDsDriverImpl_Open(PIDSDRIVER iface)
1530 {
1531     ICOM_THIS(IDsDriverImpl,iface);
1532     int enable = 0;
1533
1534     TRACE("(%p)\n",iface);
1535     /* make sure the card doesn't start playing before we want it to */
1536 #if 0
1537     if (ioctl(WOutDev[This->wDevID].unixdev, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
1538         ERR("ioctl failed (%d)\n", errno);
1539         return DSERR_GENERIC;
1540     }
1541 #endif
1542     return DS_OK;
1543 }
1544
1545 static HRESULT WINAPI IDsDriverImpl_Close(PIDSDRIVER iface)
1546 {
1547     ICOM_THIS(IDsDriverImpl,iface);
1548     TRACE("(%p)\n",iface);
1549     if (This->primary) {
1550         ERR("problem with DirectSound: primary not released\n");
1551         return DSERR_GENERIC;
1552     }
1553     return DS_OK;
1554 }
1555
1556 static HRESULT WINAPI IDsDriverImpl_GetCaps(PIDSDRIVER iface, PDSDRIVERCAPS pCaps)
1557 {
1558     /* ICOM_THIS(IDsDriverImpl,iface); */
1559     TRACE("(%p,%p)\n",iface,pCaps);
1560     memset(pCaps, 0, sizeof(*pCaps));
1561     /* FIXME: need to check actual capabilities */
1562     pCaps->dwFlags = DSCAPS_PRIMARYMONO | DSCAPS_PRIMARYSTEREO |
1563         DSCAPS_PRIMARY8BIT | DSCAPS_PRIMARY16BIT;
1564     pCaps->dwPrimaryBuffers = 1;
1565     pCaps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
1566     pCaps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
1567     /* the other fields only apply to secondary buffers, which we don't support
1568      * (unless we want to mess with wavetable synthesizers and MIDI) */
1569     return DS_OK;
1570 }
1571
1572 static HRESULT WINAPI IDsDriverImpl_CreateSoundBuffer(PIDSDRIVER iface,
1573                                                       LPWAVEFORMATEX pwfx,
1574                                                       DWORD dwFlags, DWORD dwCardAddress,
1575                                                       LPDWORD pdwcbBufferSize,
1576                                                       LPBYTE *ppbBuffer,
1577                                                       LPVOID *ppvObj)
1578 {
1579     ICOM_THIS(IDsDriverImpl,iface);
1580     IDsDriverBufferImpl** ippdsdb = (IDsDriverBufferImpl**)ppvObj;
1581     HRESULT err;
1582 #if 0
1583     audio_buf_info info;
1584 #endif
1585     int enable = 0;
1586
1587     TRACE("(%p,%p,%lx,%lx)\n",iface,pwfx,dwFlags,dwCardAddress);
1588     /* we only support primary buffers */
1589     if (!(dwFlags & DSBCAPS_PRIMARYBUFFER))
1590         return DSERR_UNSUPPORTED;
1591     if (This->primary)
1592         return DSERR_ALLOCATED;
1593     if (dwFlags & (DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN))
1594         return DSERR_CONTROLUNAVAIL;
1595
1596     *ippdsdb = (IDsDriverBufferImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverBufferImpl));
1597     if (*ippdsdb == NULL)
1598         return DSERR_OUTOFMEMORY;
1599     (*ippdsdb)->lpVtbl  = &dsdbvt;
1600     (*ippdsdb)->ref     = 1;
1601     (*ippdsdb)->drv     = This;
1602
1603     /* check how big the DMA buffer is now */
1604 #if 0
1605     if (ioctl(WOutDev[This->wDevID].unixdev, SNDCTL_DSP_GETOSPACE, &info) < 0) {
1606         ERR("ioctl failed (%d)\n", errno);
1607         HeapFree(GetProcessHeap(),0,*ippdsdb);
1608         *ippdsdb = NULL;
1609         return DSERR_GENERIC;
1610     }
1611 #endif
1612     WOutDev[This->wDevID].maplen =64*1024; /* Map 64 K at a time */
1613
1614 #if 0
1615     (*ippdsdb)->buflen = info.fragstotal * info.fragsize;
1616 #endif
1617     /* map the DMA buffer */
1618     err = DSDB_MapPrimary(*ippdsdb);
1619     if (err != DS_OK) {
1620         HeapFree(GetProcessHeap(),0,*ippdsdb);
1621         *ippdsdb = NULL;
1622         return err;
1623     }
1624
1625     /* primary buffer is ready to go */
1626     *pdwcbBufferSize    = WOutDev[This->wDevID].maplen;
1627     *ppbBuffer          = WOutDev[This->wDevID].mapping;
1628
1629     /* some drivers need some extra nudging after mapping */
1630 #if 0
1631     if (ioctl(WOutDev[This->wDevID].unixdev, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
1632         ERR("ioctl failed (%d)\n", errno);
1633         return DSERR_GENERIC;
1634     }
1635 #endif
1636
1637     This->primary = *ippdsdb;
1638
1639     return DS_OK;
1640 }
1641
1642 static HRESULT WINAPI IDsDriverImpl_DuplicateSoundBuffer(PIDSDRIVER iface,
1643                                                          PIDSDRIVERBUFFER pBuffer,
1644                                                          LPVOID *ppvObj)
1645 {
1646     /* ICOM_THIS(IDsDriverImpl,iface); */
1647     TRACE("(%p,%p): stub\n",iface,pBuffer);
1648     return DSERR_INVALIDCALL;
1649 }
1650
1651 static ICOM_VTABLE(IDsDriver) dsdvt =
1652 {
1653     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1654     IDsDriverImpl_QueryInterface,
1655     IDsDriverImpl_AddRef,
1656     IDsDriverImpl_Release,
1657     IDsDriverImpl_GetDriverDesc,
1658     IDsDriverImpl_Open,
1659     IDsDriverImpl_Close,
1660     IDsDriverImpl_GetCaps,
1661     IDsDriverImpl_CreateSoundBuffer,
1662     IDsDriverImpl_DuplicateSoundBuffer
1663 };
1664
1665 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
1666 {
1667     IDsDriverImpl** idrv = (IDsDriverImpl**)drv;
1668
1669     /* the HAL isn't much better than the HEL if we can't do mmap() */
1670     if (!(WOutDev[wDevID].caps.dwSupport & WAVECAPS_DIRECTSOUND)) {
1671         ERR("DirectSound flag not set\n");
1672         MESSAGE("This sound card's driver does not support direct access\n");
1673         MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
1674         return MMSYSERR_NOTSUPPORTED;
1675     }
1676
1677     *idrv = (IDsDriverImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverImpl));
1678     if (!*idrv)
1679         return MMSYSERR_NOMEM;
1680     (*idrv)->lpVtbl     = &dsdvt;
1681     (*idrv)->ref        = 1;
1682
1683     (*idrv)->wDevID     = wDevID;
1684     (*idrv)->primary    = NULL;
1685     return MMSYSERR_NOERROR;
1686 }
1687
1688 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
1689 {
1690     memset(desc, 0, sizeof(*desc));
1691     strcpy(desc->szDesc, "Wine LIBAUDIOIO DirectSound Driver");
1692     strcpy(desc->szDrvName, "wineaudioio.drv");
1693     return MMSYSERR_NOERROR;
1694 }
1695
1696 static DWORD wodDsGuid(UINT wDevID, LPGUID pGuid)
1697 {
1698     memcpy(pGuid, &DSDEVID_DefaultPlayback, sizeof(GUID));
1699     return MMSYSERR_NOERROR;
1700 }
1701
1702 /*======================================================================*
1703  *                  Low level WAVE IN implementation                    *
1704  *======================================================================*/
1705
1706 /**************************************************************************
1707  *                      widGetDevCaps                           [internal]
1708  */
1709 static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPSA lpCaps, DWORD dwSize)
1710 {
1711     TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
1712
1713     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1714
1715     if (wDevID >= MAX_WAVEINDRV) {
1716         TRACE("MAX_WAVINDRV reached !\n");
1717         return MMSYSERR_BADDEVICEID;
1718     }
1719
1720     memcpy(lpCaps, &WInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1721     return MMSYSERR_NOERROR;
1722 }
1723
1724 /**************************************************************************
1725  *                              widRecorder                     [internal]
1726  */
1727 static  DWORD   CALLBACK        widRecorder(LPVOID pmt)
1728 {
1729     WORD                uDevID = (DWORD)pmt;
1730     WINE_WAVEIN*        wwi = (WINE_WAVEIN*)&WInDev[uDevID];
1731     WAVEHDR*            lpWaveHdr;
1732     DWORD               dwSleepTime;
1733     MSG                 msg;
1734     DWORD               bytesRead;
1735
1736
1737         int fragments;
1738         int fragsize;
1739         int fragstotal;
1740         int bytes;
1741
1742
1743     int xs;
1744
1745         LPVOID          buffer = HeapAlloc(GetProcessHeap(),
1746                                            HEAP_ZERO_MEMORY,
1747                                        wwi->dwFragmentSize);
1748
1749     LPVOID              pOffset = buffer;
1750
1751     PeekMessageA(&msg, 0, 0, 0, 0);
1752     wwi->state = WINE_WS_STOPPED;
1753     wwi->dwTotalRecorded = 0;
1754
1755     SetEvent(wwi->hEvent);
1756
1757
1758         /* make sleep time to be # of ms to output a fragment */
1759     dwSleepTime = (wwi->dwFragmentSize * 1000) / wwi->format.wf.nAvgBytesPerSec;
1760     TRACE("sleeptime=%ld ms\n", dwSleepTime);
1761
1762     for (; ; ) {
1763         /* wait for dwSleepTime or an event in thread's queue */
1764         /* FIXME: could improve wait time depending on queue state,
1765          * ie, number of queued fragments
1766          */
1767
1768         if (wwi->lpQueuePtr != NULL && wwi->state == WINE_WS_PLAYING)
1769         {
1770             lpWaveHdr = wwi->lpQueuePtr;
1771
1772             bytes=fragsize=AudioIORecordingAvailable();
1773        fragments=fragstotal=1;
1774
1775             TRACE("info={frag=%d fsize=%d ftotal=%d bytes=%d}\n", fragments, fragsize, fragstotal, bytes);
1776
1777
1778             /* read all the fragments accumulated so far */
1779             while ((fragments > 0) && (wwi->lpQueuePtr))
1780             {
1781                 fragments --;
1782
1783                 if (lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded >= wwi->dwFragmentSize)
1784                 {
1785                     /* directly read fragment in wavehdr */
1786                     bytesRead = AudioIORead(
1787                                      lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded,
1788                                      wwi->dwFragmentSize);
1789
1790                     TRACE("bytesRead=%ld (direct)\n", bytesRead);
1791                     if (bytesRead != (DWORD) -1)
1792                     {
1793                         /* update number of bytes recorded in current buffer and by this device */
1794                         lpWaveHdr->dwBytesRecorded += bytesRead;
1795                         wwi->dwTotalRecorded       += bytesRead;
1796
1797                         /* buffer is full. notify client */
1798                         if (lpWaveHdr->dwBytesRecorded == lpWaveHdr->dwBufferLength)
1799                         {
1800                             /* must copy the value of next waveHdr, because we have no idea of what
1801                              * will be done with the content of lpWaveHdr in callback
1802                              */
1803                             LPWAVEHDR   lpNext = lpWaveHdr->lpNext;
1804
1805                             lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1806                             lpWaveHdr->dwFlags |=  WHDR_DONE;
1807
1808                             if (LIBAUDIOIO_NotifyClient(uDevID, WIM_DATA,
1809                                                  (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR)
1810                             {
1811                                 WARN("can't notify client !\n");
1812                             }
1813                             lpWaveHdr = wwi->lpQueuePtr = lpNext;
1814                         }
1815                     }
1816                 }
1817                 else
1818                 {
1819                     /* read the fragment in a local buffer */
1820                     bytesRead = AudioIORead( buffer, wwi->dwFragmentSize);
1821                     pOffset = buffer;
1822
1823                     TRACE("bytesRead=%ld (local)\n", bytesRead);
1824
1825                     /* copy data in client buffers */
1826                     while (bytesRead != (DWORD) -1 && bytesRead > 0)
1827                     {
1828                         DWORD dwToCopy = min (bytesRead, lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded);
1829
1830                         memcpy(lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded,
1831                                pOffset,
1832                                dwToCopy);
1833
1834                         /* update number of bytes recorded in current buffer and by this device */
1835                         lpWaveHdr->dwBytesRecorded += dwToCopy;
1836                         wwi->dwTotalRecorded += dwToCopy;
1837                         bytesRead -= dwToCopy;
1838                         pOffset   += dwToCopy;
1839
1840                         /* client buffer is full. notify client */
1841                         if (lpWaveHdr->dwBytesRecorded == lpWaveHdr->dwBufferLength)
1842                         {
1843                             /* must copy the value of next waveHdr, because we have no idea of what
1844                              * will be done with the content of lpWaveHdr in callback
1845                              */
1846                             LPWAVEHDR   lpNext = lpWaveHdr->lpNext;
1847                             TRACE("lpNext=%p\n", lpNext);
1848
1849                             lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1850                             lpWaveHdr->dwFlags |=  WHDR_DONE;
1851
1852                             if (LIBAUDIOIO_NotifyClient(uDevID, WIM_DATA,
1853                                                  (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR)
1854                             {
1855                                 WARN("can't notify client !\n");
1856                             }
1857
1858                             wwi->lpQueuePtr = lpWaveHdr = lpNext;
1859                             if (!lpNext && bytesRead) {
1860                                 /* no more buffer to copy data to, but we did read more.
1861                                  * what hasn't been copied will be dropped
1862                                  */
1863                                 WARN("buffer under run! %lu bytes dropped.\n", bytesRead);
1864                                 wwi->lpQueuePtr = NULL;
1865                                 break;
1866                             }
1867                         }
1868                     }
1869                 }
1870             }
1871         }
1872
1873         MsgWaitForMultipleObjects(0, NULL, FALSE, dwSleepTime, QS_POSTMESSAGE);
1874
1875         while (PeekMessageA(&msg, 0, WINE_WM_FIRST, WINE_WM_LAST, PM_REMOVE)) {
1876
1877             TRACE("msg=0x%x wParam=0x%x lParam=0x%lx\n", msg.message, msg.wParam, msg.lParam);
1878             switch (msg.message) {
1879             case WINE_WM_PAUSING:
1880                 wwi->state = WINE_WS_PAUSED;
1881
1882                 AudioIORecordingPause();
1883                 SetEvent(wwi->hEvent);
1884                 break;
1885             case WINE_WM_RESTARTING:
1886             {
1887
1888                 wwi->state = WINE_WS_PLAYING;
1889
1890                 if (wwi->bTriggerSupport)
1891                 {
1892                     /* start the recording */
1893                     AudioIORecordingResume();
1894                 }
1895                 else
1896                 {
1897                     unsigned char data[4];
1898                     /* read 4 bytes to start the recording */
1899                     AudioIORead( data, 4);
1900                 }
1901
1902                 SetEvent(wwi->hEvent);
1903                 break;
1904             }
1905             case WINE_WM_HEADER:
1906                 lpWaveHdr = (LPWAVEHDR)msg.lParam;
1907                 lpWaveHdr->lpNext = 0;
1908
1909                 /* insert buffer at the end of queue */
1910                 {
1911                     LPWAVEHDR*  wh;
1912                     for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
1913                     *wh = lpWaveHdr;
1914                 }
1915                 break;
1916             case WINE_WM_RESETTING:
1917                 wwi->state = WINE_WS_STOPPED;
1918                 /* return all buffers to the app */
1919                 for (lpWaveHdr = wwi->lpQueuePtr; lpWaveHdr; lpWaveHdr = lpWaveHdr->lpNext) {
1920                     TRACE("reset %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
1921                     lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1922                     lpWaveHdr->dwFlags |= WHDR_DONE;
1923
1924                     if (LIBAUDIOIO_NotifyClient(uDevID, WIM_DATA,
1925                                          (DWORD)lpWaveHdr, 0) != MMSYSERR_NOERROR) {
1926                         WARN("can't notify client !\n");
1927                     }
1928                 }
1929                 wwi->lpQueuePtr = NULL;
1930                 SetEvent(wwi->hEvent);
1931                 break;
1932             case WINE_WM_CLOSING:
1933                 wwi->hThread = 0;
1934                 wwi->state = WINE_WS_CLOSED;
1935                 SetEvent(wwi->hEvent);
1936                 HeapFree(GetProcessHeap(), 0, buffer);
1937                 ExitThread(0);
1938                 /* shouldn't go here */
1939             default:
1940                 FIXME("unknown message %d\n", msg.message);
1941                 break;
1942             }
1943         }
1944   }
1945     ExitThread(0);
1946     /* just for not generating compilation warnings... should never be executed */
1947     return 0;
1948 }
1949
1950
1951 /**************************************************************************
1952  *                              widOpen                         [internal]
1953  */
1954 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1955 {
1956     int                 audio;
1957     int                 fragment_size;
1958     int                 sample_rate;
1959     int                 format;
1960     int                 dsp_stereo;
1961     WINE_WAVEIN*        wwi;
1962     int                 audio_fragment;
1963
1964     TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
1965     if (lpDesc == NULL) {
1966         WARN("Invalid Parameter !\n");
1967         return MMSYSERR_INVALPARAM;
1968     }
1969     if (wDevID >= MAX_WAVEINDRV) return MMSYSERR_BADDEVICEID;
1970
1971     /* only PCM format is supported so far... */
1972     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1973         lpDesc->lpFormat->nChannels == 0 ||
1974         lpDesc->lpFormat->nSamplesPerSec == 0) {
1975         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1976              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1977              lpDesc->lpFormat->nSamplesPerSec);
1978         return WAVERR_BADFORMAT;
1979     }
1980
1981     if (dwFlags & WAVE_FORMAT_QUERY) {
1982         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1983              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1984              lpDesc->lpFormat->nSamplesPerSec);
1985         return MMSYSERR_NOERROR;
1986     }
1987
1988     if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED;
1989     audio = AudioIOOpenX( O_RDONLY|O_NDELAY, &spec[RECORD],&spec[RECORD]);
1990     if (audio == -1) {
1991         WARN("can't open sound device %s (%s)!\n", SOUND_DEV, strerror(errno));
1992         return MMSYSERR_ALLOCATED;
1993     }
1994     fcntl(audio, F_SETFD, 1); /* set close on exec flag */
1995
1996     wwi = &WInDev[wDevID];
1997     if (wwi->lpQueuePtr) {
1998         WARN("Should have an empty queue (%p)\n", wwi->lpQueuePtr);
1999         wwi->lpQueuePtr = NULL;
2000     }
2001     wwi->unixdev = audio;
2002     wwi->dwTotalRecorded = 0;
2003     wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2004
2005     memcpy(&wwi->waveDesc, lpDesc,           sizeof(WAVEOPENDESC));
2006     memcpy(&wwi->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
2007
2008     if (wwi->format.wBitsPerSample == 0) {
2009         WARN("Resetting zeroed wBitsPerSample\n");
2010         wwi->format.wBitsPerSample = 8 *
2011             (wwi->format.wf.nAvgBytesPerSec /
2012              wwi->format.wf.nSamplesPerSec) /
2013             wwi->format.wf.nChannels;
2014     }
2015
2016     spec[RECORD].rate=sample_rate = wwi->format.wf.nSamplesPerSec;
2017     dsp_stereo = ((spec[RECORD].channels=wwi->format.wf.nChannels) > 1) ? TRUE : FALSE;
2018     spec[RECORD].precision= wwi->format.wBitsPerSample;
2019     spec[RECORD].type=(spec[RECORD].precision==16)?TYPE_SIGNED:TYPE_UNSIGNED;
2020
2021     /* This is actually hand tuned to work so that my SB Live:
2022      * - does not skip
2023      * - does not buffer too much
2024      * when sending with the Shoutcast winamp plugin
2025      */
2026     /* 7 fragments max, 2^10 = 1024 bytes per fragment */
2027     audio_fragment = 0x0007000A;
2028     fragment_size=4096;
2029     if (fragment_size == -1) {
2030         AudioIOClose();
2031         wwi->unixdev = -1;
2032         return MMSYSERR_NOTENABLED;
2033     }
2034     wwi->dwFragmentSize = fragment_size;
2035
2036     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n",
2037           wwi->format.wBitsPerSample, wwi->format.wf.nAvgBytesPerSec,
2038           wwi->format.wf.nSamplesPerSec, wwi->format.wf.nChannels,
2039           wwi->format.wf.nBlockAlign);
2040
2041     wwi->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
2042     wwi->hThread = CreateThread(NULL, 0, widRecorder, (LPVOID)(DWORD)wDevID, 0, &(wwi->dwThreadID));
2043     WaitForSingleObject(wwi->hEvent, INFINITE);
2044
2045    if (LIBAUDIOIO_NotifyClient(wDevID, WIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
2046         WARN("can't notify client !\n");
2047         return MMSYSERR_INVALPARAM;
2048     }
2049     return MMSYSERR_NOERROR;
2050 }
2051
2052 /**************************************************************************
2053  *                              widClose                        [internal]
2054  */
2055 static DWORD widClose(WORD wDevID)
2056 {
2057     WINE_WAVEIN*        wwi;
2058
2059     TRACE("(%u);\n", wDevID);
2060     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].unixdev == -1) {
2061         WARN("can't close !\n");
2062         return MMSYSERR_INVALHANDLE;
2063     }
2064
2065     wwi = &WInDev[wDevID];
2066
2067     if (wwi->lpQueuePtr != NULL) {
2068         WARN("still buffers open !\n");
2069         return WAVERR_STILLPLAYING;
2070     }
2071
2072     PostThreadMessageA(wwi->dwThreadID, WINE_WM_CLOSING, 0, 0);
2073     WaitForSingleObject(wwi->hEvent, INFINITE);
2074     CloseHandle(wwi->hEvent);
2075     AudioIOClose();
2076     wwi->unixdev = -1;
2077     wwi->dwFragmentSize = 0;
2078     if (LIBAUDIOIO_NotifyClient(wDevID, WIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
2079         WARN("can't notify client !\n");
2080         return MMSYSERR_INVALPARAM;
2081     }
2082     return MMSYSERR_NOERROR;
2083 }
2084
2085 /**************************************************************************
2086  *                              widAddBuffer            [internal]
2087  */
2088 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
2089 {
2090     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
2091
2092     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].unixdev == -1) {
2093         WARN("can't do it !\n");
2094         return MMSYSERR_INVALHANDLE;
2095     }
2096     if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) {
2097         TRACE("never been prepared !\n");
2098         return WAVERR_UNPREPARED;
2099     }
2100     if (lpWaveHdr->dwFlags & WHDR_INQUEUE) {
2101         TRACE("header already in use !\n");
2102         return WAVERR_STILLPLAYING;
2103     }
2104
2105     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
2106     lpWaveHdr->dwFlags &= ~WHDR_DONE;
2107     lpWaveHdr->dwBytesRecorded = 0;
2108         lpWaveHdr->lpNext = NULL;
2109
2110     PostThreadMessageA(WInDev[wDevID].dwThreadID, WINE_WM_HEADER, 0, (DWORD)lpWaveHdr);
2111     return MMSYSERR_NOERROR;
2112 }
2113
2114 /**************************************************************************
2115  *                              widPrepare                      [internal]
2116  */
2117 static DWORD widPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
2118 {
2119     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
2120
2121     if (wDevID >= MAX_WAVEINDRV) return MMSYSERR_INVALHANDLE;
2122
2123     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
2124         return WAVERR_STILLPLAYING;
2125
2126     lpWaveHdr->dwFlags |= WHDR_PREPARED;
2127     lpWaveHdr->dwFlags &= ~(WHDR_INQUEUE|WHDR_DONE);
2128     lpWaveHdr->dwBytesRecorded = 0;
2129     TRACE("header prepared !\n");
2130     return MMSYSERR_NOERROR;
2131 }
2132
2133 /**************************************************************************
2134  *                              widUnprepare                    [internal]
2135  */
2136 static DWORD widUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
2137 {
2138     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
2139     if (wDevID >= MAX_WAVEINDRV) return MMSYSERR_INVALHANDLE;
2140
2141     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
2142         return WAVERR_STILLPLAYING;
2143
2144     lpWaveHdr->dwFlags &= ~(WHDR_PREPARED|WHDR_INQUEUE);
2145     lpWaveHdr->dwFlags |= WHDR_DONE;
2146
2147     return MMSYSERR_NOERROR;
2148 }
2149
2150 /**************************************************************************
2151  *                      widStart                                [internal]
2152  */
2153 static DWORD widStart(WORD wDevID)
2154 {
2155     TRACE("(%u);\n", wDevID);
2156     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].unixdev == -1) {
2157         WARN("can't start recording !\n");
2158         return MMSYSERR_INVALHANDLE;
2159     }
2160
2161     PostThreadMessageA(WInDev[wDevID].dwThreadID, WINE_WM_RESTARTING, 0, 0);
2162     WaitForSingleObject(WInDev[wDevID].hEvent, INFINITE);
2163     return MMSYSERR_NOERROR;
2164 }
2165
2166 /**************************************************************************
2167  *                      widStop                                 [internal]
2168  */
2169 static DWORD widStop(WORD wDevID)
2170 {
2171     TRACE("(%u);\n", wDevID);
2172     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].unixdev == -1) {
2173         WARN("can't stop !\n");
2174         return MMSYSERR_INVALHANDLE;
2175     }
2176     /* FIXME: reset aint stop */
2177     PostThreadMessageA(WInDev[wDevID].dwThreadID, WINE_WM_RESETTING, 0, 0);
2178     WaitForSingleObject(WInDev[wDevID].hEvent, INFINITE);
2179
2180     return MMSYSERR_NOERROR;
2181 }
2182
2183 /**************************************************************************
2184  *                      widReset                                [internal]
2185  */
2186 static DWORD widReset(WORD wDevID)
2187 {
2188     TRACE("(%u);\n", wDevID);
2189     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].unixdev == -1) {
2190         WARN("can't reset !\n");
2191         return MMSYSERR_INVALHANDLE;
2192     }
2193     PostThreadMessageA(WInDev[wDevID].dwThreadID, WINE_WM_RESETTING, 0, 0);
2194     WaitForSingleObject(WInDev[wDevID].hEvent, INFINITE);
2195     return MMSYSERR_NOERROR;
2196 }
2197
2198 /**************************************************************************
2199  *                              widGetPosition                  [internal]
2200  */
2201 static DWORD widGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
2202 {
2203     int                 time;
2204     WINE_WAVEIN*        wwi;
2205
2206     TRACE("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
2207
2208     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].unixdev == -1) {
2209         WARN("can't get pos !\n");
2210         return MMSYSERR_INVALHANDLE;
2211     }
2212     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
2213
2214     wwi = &WInDev[wDevID];
2215
2216     TRACE("wType=%04X !\n", lpTime->wType);
2217     TRACE("wBitsPerSample=%u\n", wwi->format.wBitsPerSample);
2218     TRACE("nSamplesPerSec=%lu\n", wwi->format.wf.nSamplesPerSec);
2219     TRACE("nChannels=%u\n", wwi->format.wf.nChannels);
2220     TRACE("nAvgBytesPerSec=%lu\n", wwi->format.wf.nAvgBytesPerSec);
2221     switch (lpTime->wType) {
2222     case TIME_BYTES:
2223         lpTime->u.cb = wwi->dwTotalRecorded;
2224         TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
2225         break;
2226     case TIME_SAMPLES:
2227         lpTime->u.sample = wwi->dwTotalRecorded * 8 /
2228             wwi->format.wBitsPerSample;
2229         TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
2230         break;
2231     case TIME_SMPTE:
2232         time = wwi->dwTotalRecorded /
2233             (wwi->format.wf.nAvgBytesPerSec / 1000);
2234         lpTime->u.smpte.hour = time / 108000;
2235         time -= lpTime->u.smpte.hour * 108000;
2236         lpTime->u.smpte.min = time / 1800;
2237         time -= lpTime->u.smpte.min * 1800;
2238         lpTime->u.smpte.sec = time / 30;
2239         time -= lpTime->u.smpte.sec * 30;
2240         lpTime->u.smpte.frame = time;
2241         lpTime->u.smpte.fps = 30;
2242         TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
2243               lpTime->u.smpte.hour, lpTime->u.smpte.min,
2244               lpTime->u.smpte.sec, lpTime->u.smpte.frame);
2245         break;
2246     case TIME_MS:
2247         lpTime->u.ms = wwi->dwTotalRecorded /
2248             (wwi->format.wf.nAvgBytesPerSec / 1000);
2249         TRACE("TIME_MS=%lu\n", lpTime->u.ms);
2250         break;
2251     default:
2252         FIXME("format not supported (%u) ! use TIME_MS !\n", lpTime->wType);
2253         lpTime->wType = TIME_MS;
2254     }
2255     return MMSYSERR_NOERROR;
2256 }
2257
2258 /**************************************************************************
2259  *                              widMessage (WINEAUDIOIO.@)
2260  */
2261 DWORD WINAPI LIBAUDIOIO_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2262                             DWORD dwParam1, DWORD dwParam2)
2263 {
2264     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
2265           wDevID, wMsg, dwUser, dwParam1, dwParam2);
2266
2267     switch (wMsg) {
2268     case DRVM_INIT:
2269     case DRVM_EXIT:
2270     case DRVM_ENABLE:
2271     case DRVM_DISABLE:
2272         /* FIXME: Pretend this is supported */
2273         return 0;
2274     case WIDM_OPEN:             return widOpen       (wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
2275     case WIDM_CLOSE:            return widClose      (wDevID);
2276     case WIDM_ADDBUFFER:        return widAddBuffer  (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2277     case WIDM_PREPARE:          return widPrepare    (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2278     case WIDM_UNPREPARE:        return widUnprepare  (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2279     case WIDM_GETDEVCAPS:       return widGetDevCaps (wDevID, (LPWAVEINCAPSA)dwParam1, dwParam2);
2280     case WIDM_GETNUMDEVS:       return wodGetNumDevs ();        /* same number of devices in output as in input */
2281     case WIDM_GETPOS:           return widGetPosition(wDevID, (LPMMTIME)dwParam1, dwParam2);
2282     case WIDM_RESET:            return widReset      (wDevID);
2283     case WIDM_START:            return widStart      (wDevID);
2284     case WIDM_STOP:             return widStop       (wDevID);
2285     case DRV_QUERYDSOUNDIFACE:  return widDsCreate   (wDevID, (PIDSCDRIVER*)dwParam1);
2286     case DRV_QUERYDSOUNDDESC:   return widDsDesc     (wDevID, (PDSDRIVERDESC)dwParam1);
2287     case DRV_QUERYDSOUNDGUID:   return widDsGuid     (wDevID, (LPGUID)dwParam1);
2288     default:
2289         FIXME("unknown message %u!\n", wMsg);
2290     }
2291     return MMSYSERR_NOTSUPPORTED;
2292 }
2293
2294 /*======================================================================*
2295  *                  Low level DSOUND capture implementation             *
2296  *======================================================================*/
2297 static DWORD widDsCreate(UINT wDevID, PIDSDRIVER* drv)
2298 {
2299     /* we can't perform memory mapping as we don't have a file stream
2300         interface with arts like we do with oss */
2301     MESSAGE("This sound card's driver does not support direct access\n");
2302     MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
2303     return MMSYSERR_NOTSUPPORTED;
2304 }
2305
2306 static DWORD widDsDesc(UINT wDevID, PDSDRIVERDESC desc)
2307 {
2308     memset(desc, 0, sizeof(*desc));
2309     strcpy(desc->szDesc, "Wine LIBAUDIOIO DirectSound Driver");
2310     strcpy(desc->szDrvName, "wineaudioio.drv");
2311     return MMSYSERR_NOERROR;
2312 }
2313
2314 static DWORD wodDsGuid(UINT wDevID, LPGUID pGuid)
2315 {
2316     memcpy(pGuid, &DSDEVID_DefaultCapture, sizeof(GUID));
2317     return MMSYSERR_NOERROR;
2318 }
2319
2320 #else /* HAVE_LIBAUDIOIO */
2321
2322 /**************************************************************************
2323  *                              wodMessage (WINEAUDIOIO.@)
2324  */
2325 DWORD WINAPI LIBAUDIOIO_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2326                             DWORD dwParam1, DWORD dwParam2)
2327 {
2328     FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2329     return MMSYSERR_NOTENABLED;
2330 }
2331
2332 /**************************************************************************
2333  *                              widMessage (WINEAUDIOIO.@)
2334  */
2335 DWORD WINAPI LIBAUDIOIO_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2336                             DWORD dwParam1, DWORD dwParam2)
2337 {
2338     FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2339     return MMSYSERR_NOTENABLED;
2340 }
2341
2342 #endif /* HAVE_LIBAUDIOIO */