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

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /*
   3  * Wine Driver for aRts Sound Server
   4  *   http://www.arts-project.org
   5  *
   6  * Copyright 1994 Martin Ayotte
   7  *           1999 Eric Pouech (async playing in waveOut/waveIn)
   8  *           2000 Eric Pouech (loops in waveOut)
   9  *           2002 Chris Morgan (aRts version of this file)
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25 /* NOTE:
  26  *    with arts we cannot stop the audio that is already in
  27  *    the servers buffer, so to reduce delays during starting
  28  *    and stoppping of audio streams adjust the
  29  *    audio buffer size in the kde control center or in the
  30  *    artsd startup script
  31  *
  32  * FIXME:
  33  *      pause in waveOut does not work correctly in loop mode
  34  *
  35  *      does something need to be done in for WaveIn DirectSound?
  36  */
  37
  38 #include "config.h"
  39 #include "wine/port.h"
  40
  41 #include <math.h>
  42 #include <stdlib.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <string.h>
  46 #ifdef HAVE_UNISTD_H
  47 # include <unistd.h>
  48 #endif
  49 #include <fcntl.h>
  50 #include "windef.h"
  51 #include "winbase.h"
  52 #include "wingdi.h"
  53 #include "winerror.h"
  54 #include "winuser.h"
  55 #include "mmddk.h"
  56 #include "dsound.h"
  57 #include "dsdriver.h"
  58 #include "arts.h"
  59 #include "wine/unicode.h"
  60 #include "wine/debug.h"
  61
  62 WINE_DEFAULT_DEBUG_CHANNEL(wave);
  63
  64 #ifdef HAVE_ARTS
  65
  66 #include <artsc.h>
  67
  68 /* The following four #defines allow you to fine-tune the packet
  69  * settings in arts for better low-latency support. You must also
  70  * adjust the latency in the KDE arts control panel. I recommend 4
  71  * fragments, 1024 bytes.
  72  *
  73  * The following is from the ARTS documentation and explains what CCCC
  74  * and SSSS mean:
  75  *
  76  * @li ARTS_P_PACKET_SETTINGS (rw) This is a way to configure packet
  77  * size & packet count at the same time.  The format is 0xCCCCSSSS,
  78  * where 2^SSSS is the packet size, and CCCC is the packet count. Note
  79  * that when writing this, you don't necessarily get the settings you
  80  * requested.
  81  */
  82 #define WAVEOUT_PACKET_CCCC 0x000C
  83 #define WAVEOUT_PACKET_SSSS 0x0008
  84 #define WAVEIN_PACKET_CCCC  0x000C
  85 #define WAVEIN_PACKET_SSSS  0x0008
  86
  87 #define BUFFER_REFILL_THRESHOLD 4
  88
  89 #define WAVEOUT_PACKET_SETTINGS ((WAVEOUT_PACKET_CCCC << 16) | (WAVEOUT_PACKET_SSSS))
  90 #define WAVEIN_PACKET_SETTINGS  ((WAVEIN_PACKET_CCCC << 16) | (WAVEIN_PACKET_SSSS))
  91
  92 #define MAX_WAVEOUTDRV  (10)
  93 #define MAX_WAVEINDRV   (10)
  94
  95 /* state diagram for waveOut writing:
  96  *
  97  * +---------+-------------+---------------+---------------------------------+
  98  * |  state  |  function   |     event     |            new state            |
  99  * +---------+-------------+---------------+---------------------------------+
 100  * |         | open()      |               | STOPPED                         |
 101  * | PAUSED  | write()     |               | PAUSED                          |
 102  * | STOPPED | write()     | <thrd create> | PLAYING                         |
 103  * | PLAYING | write()     | HEADER        | PLAYING                         |
 104  * | (other) | write()     | <error>       |                                 |
 105  * | (any)   | pause()     | PAUSING       | PAUSED                          |
 106  * | PAUSED  | restart()   | RESTARTING    | PLAYING (if no thrd => STOPPED) |
 107  * | (any)   | reset()     | RESETTING     | STOPPED                         |
 108  * | (any)   | close()     | CLOSING       | CLOSED                          |
 109  * +---------+-------------+---------------+---------------------------------+
 110  */
 111
 112 /* states of the playing device */
 113 #define WINE_WS_PLAYING         0
 114 #define WINE_WS_PAUSED          1
 115 #define WINE_WS_STOPPED         2
 116 #define WINE_WS_CLOSED          3
 117
 118 /* events to be send to device */
 119 enum win_wm_message {
 120     WINE_WM_PAUSING = WM_USER + 1, WINE_WM_RESTARTING, WINE_WM_RESETTING, WINE_WM_HEADER,
 121     WINE_WM_UPDATE, WINE_WM_BREAKLOOP, WINE_WM_CLOSING, WINE_WM_STARTING, WINE_WM_STOPPING
 122 };
 123
 124 typedef struct {
 125     enum win_wm_message         msg;    /* message identifier */
 126     DWORD                       param;  /* parameter for this message */
 127     HANDLE                      hEvent; /* if message is synchronous, handle of event for synchro */
 128 } RING_MSG;
 129
 130 /* implement an in-process message ring for better performance
 131  * (compared to passing thru the server)
 132  * this ring will be used by the input (resp output) record (resp playback) routine
 133  */
 134 #define ARTS_RING_BUFFER_INCREMENT      64
 135 typedef struct {
 136     RING_MSG                    * messages;
 137     int                         ring_buffer_size;
 138     int                         msg_tosave;
 139     int                         msg_toget;
 140     HANDLE                      msg_event;
 141     CRITICAL_SECTION            msg_crst;
 142 } ARTS_MSG_RING;
 143
 144 typedef struct {
 145     volatile int                state;                  /* one of the WINE_WS_ manifest constants */
 146     WAVEOPENDESC                waveDesc;
 147     WORD                        wFlags;
 148     PCMWAVEFORMAT               format;
 149     WAVEOUTCAPSW                caps;
 150     char                        interface_name[32];
 151
 152     DWORD                       dwSleepTime;            /* Num of milliseconds to sleep between filling the dsp buffers */
 153
 154     /* arts information */
 155     arts_stream_t               play_stream;            /* the stream structure we get from arts when opening a stream for playing */
 156     DWORD                       dwBufferSize;           /* size of whole buffer in bytes */
 157     int                         packetSettings;
 158
 159     char*                       sound_buffer;
 160     long                        buffer_size;
 161
 162     DWORD                       volume_left;            /* volume control information */
 163     DWORD                       volume_right;
 164
 165     LPWAVEHDR                   lpQueuePtr;             /* start of queued WAVEHDRs (waiting to be notified) */
 166     LPWAVEHDR                   lpPlayPtr;              /* start of not yet fully played buffers */
 167     DWORD                       dwPartialOffset;        /* Offset of not yet written bytes in lpPlayPtr */
 168
 169     LPWAVEHDR                   lpLoopPtr;              /* pointer of first buffer in loop, if any */
 170     DWORD                       dwLoops;                /* private copy of loop counter */
 171
 172     DWORD                       dwPlayedTotal;          /* number of bytes actually played since opening */
 173     DWORD                       dwWrittenTotal;         /* number of bytes written to the audio device since opening */
 174
 175     /* synchronization stuff */
 176     HANDLE                      hStartUpEvent;
 177     HANDLE                      hThread;
 178     DWORD                       dwThreadID;
 179     ARTS_MSG_RING               msgRing;
 180 } WINE_WAVEOUT;
 181
 182 typedef struct {
 183     volatile int                state;                  /* one of the WINE_WS_ manifest constants */
 184     WAVEOPENDESC                waveDesc;
 185     WORD                        wFlags;
 186     PCMWAVEFORMAT               format;
 187     WAVEINCAPSW                 caps;
 188     char                        interface_name[32];
 189
 190     /* arts information */
 191     arts_stream_t               record_stream;          /* the stream structure we get from arts when opening a stream for recording */
 192     int                         packetSettings;
 193
 194     LPWAVEHDR                   lpQueuePtr;
 195     DWORD                       dwRecordedTotal;
 196
 197     /* synchronization stuff */
 198     HANDLE                      hStartUpEvent;
 199     HANDLE                      hThread;
 200     DWORD                       dwThreadID;
 201     ARTS_MSG_RING               msgRing;
 202 } WINE_WAVEIN;
 203
 204 static WINE_WAVEOUT     WOutDev   [MAX_WAVEOUTDRV];
 205 static WINE_WAVEIN      WInDev    [MAX_WAVEINDRV];
 206
 207 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv);
 208 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc);
 209
 210 /* These strings used only for tracing */
 211 static const char *wodPlayerCmdString[] = {
 212     "WINE_WM_PAUSING",
 213     "WINE_WM_RESTARTING",
 214     "WINE_WM_RESETTING",
 215     "WINE_WM_HEADER",
 216     "WINE_WM_UPDATE",
 217     "WINE_WM_BREAKLOOP",
 218     "WINE_WM_CLOSING",
 219     "WINE_WM_STARTING",
 220     "WINE_WM_STOPPING",
 221 };
 222
 223 static DWORD bytes_to_mmtime(LPMMTIME lpTime, DWORD position,
 224                              PCMWAVEFORMAT* format)
 225 {
 226     TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%lu nChannels=%u nAvgBytesPerSec=%lu\n",
 227           lpTime->wType, format->wBitsPerSample, format->wf.nSamplesPerSec,
 228           format->wf.nChannels, format->wf.nAvgBytesPerSec);
 229     TRACE("Position in bytes=%lu\n", position);
 230
 231     switch (lpTime->wType) {
 232     case TIME_SAMPLES:
 233         lpTime->u.sample = position / (format->wBitsPerSample / 8 * format->wf.nChannels);
 234         TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
 235         break;
 236     case TIME_MS:
 237         lpTime->u.ms = 1000.0 * position / (format->wBitsPerSample / 8 * format->wf.nChannels * format->wf.nSamplesPerSec);
 238         TRACE("TIME_MS=%lu\n", lpTime->u.ms);
 239         break;
 240     case TIME_SMPTE:
 241         lpTime->u.smpte.fps = 30;
 242         position = position / (format->wBitsPerSample / 8 * format->wf.nChannels);
 243         position += (format->wf.nSamplesPerSec / lpTime->u.smpte.fps) - 1; /* round up */
 244         lpTime->u.smpte.sec = position / format->wf.nSamplesPerSec;
 245         position -= lpTime->u.smpte.sec * format->wf.nSamplesPerSec;
 246         lpTime->u.smpte.min = lpTime->u.smpte.sec / 60;
 247         lpTime->u.smpte.sec -= 60 * lpTime->u.smpte.min;
 248         lpTime->u.smpte.hour = lpTime->u.smpte.min / 60;
 249         lpTime->u.smpte.min -= 60 * lpTime->u.smpte.hour;
 250         lpTime->u.smpte.fps = 30;
 251         lpTime->u.smpte.frame = position * lpTime->u.smpte.fps / format->wf.nSamplesPerSec;
 252         TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
 253               lpTime->u.smpte.hour, lpTime->u.smpte.min,
 254               lpTime->u.smpte.sec, lpTime->u.smpte.frame);
 255         break;
 256     default:
 257         WARN("Format %d not supported, using TIME_BYTES !\n", lpTime->wType);
 258         lpTime->wType = TIME_BYTES;
 259         /* fall through */
 260     case TIME_BYTES:
 261         lpTime->u.cb = position;
 262         TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
 263         break;
 264     }
 265     return MMSYSERR_NOERROR;
 266 }
 267
 268 /*======================================================================*
 269  *                  Low level WAVE implementation                       *
 270  *======================================================================*/
 271
 272 /* Volume functions derived from Alsaplayer source */
 273 /* length is the number of 16 bit samples */
 274 static void volume_effect16(void *bufin, void* bufout, int length, int left,
 275                             int right, int nChannels)
 276 {
 277   short *d_out = (short *)bufout;
 278   short *d_in = (short *)bufin;
 279   int i, v;
 280
 281 /*
 282   TRACE("length == %d, nChannels == %d\n", length, nChannels);
 283 */
 284
 285   if (right == -1) right = left;
 286
 287   for(i = 0; i < length; i+=(nChannels))
 288   {
 289     v = (int) ((*(d_in++) * left) / 100);
 290     *(d_out++) = (v>32767) ? 32767 : ((v<-32768) ? -32768 : v);
 291     if(nChannels == 2)
 292     {
 293       v = (int) ((*(d_in++) * right) / 100);
 294       *(d_out++) = (v>32767) ? 32767 : ((v<-32768) ? -32768 : v);
 295     }
 296   }
 297 }
 298
 299 /* length is the number of 8 bit samples */
 300 static void volume_effect8(void *bufin, void* bufout, int length, int left,
 301                            int right, int       nChannels)
 302 {
 303   BYTE *d_out = (BYTE *)bufout;
 304   BYTE *d_in = (BYTE *)bufin;
 305   int i, v;
 306
 307 /*
 308   TRACE("length == %d, nChannels == %d\n", length, nChannels);
 309 */
 310
 311   if (right == -1) right = left;
 312
 313   for(i = 0; i < length; i+=(nChannels))
 314   {
 315     v = (BYTE) ((*(d_in++) * left) / 100);
 316     *(d_out++) = (v>255) ? 255 : ((v<0) ? 0 : v);
 317     if(nChannels == 2)
 318     {
 319       v = (BYTE) ((*(d_in++) * right) / 100);
 320       *(d_out++) = (v>255) ? 255 : ((v<0) ? 0 : v);
 321     }
 322   }
 323 }
 324
 325 /******************************************************************
 326  *              ARTS_CloseWaveOutDevice
 327  *
 328  */
 329 static void ARTS_CloseWaveOutDevice(WINE_WAVEOUT* wwo)
 330 {
 331   arts_close_stream(wwo->play_stream);  /* close the arts stream */
 332   wwo->play_stream = (arts_stream_t*)-1;
 333
 334   /* free up the buffer we use for volume and reset the size */
 335   HeapFree(GetProcessHeap(), 0, wwo->sound_buffer);
 336   wwo->sound_buffer = NULL;
 337   wwo->buffer_size = 0;
 338 }
 339
 340 /******************************************************************
 341  *              ARTS_CloseWaveInDevice
 342  *
 343  */
 344 static void ARTS_CloseWaveInDevice(WINE_WAVEIN* wwi)
 345 {
 346   arts_close_stream(wwi->record_stream);        /* close the arts stream */
 347   wwi->record_stream = (arts_stream_t*)-1;
 348 }
 349
 350 /******************************************************************
 351  *              ARTS_Init
 352  */
 353 static int      ARTS_Init(void)
 354 {
 355   return arts_init();  /* initialize arts and return errorcode */
 356 }
 357
 358 /******************************************************************
 359  *              ARTS_WaveClose
 360  */
 361 LONG            ARTS_WaveClose(void)
 362 {
 363     int iDevice;
 364
 365     /* close all open devices */
 366     for(iDevice = 0; iDevice < MAX_WAVEOUTDRV; iDevice++)
 367     {
 368       if(WOutDev[iDevice].play_stream != (arts_stream_t*)-1)
 369       {
 370         ARTS_CloseWaveOutDevice(&WOutDev[iDevice]);
 371       }
 372     }
 373
 374     for(iDevice = 0; iDevice < MAX_WAVEINDRV; iDevice++)
 375     {
 376       if(WInDev[iDevice].record_stream != (arts_stream_t*)-1)
 377       {
 378         ARTS_CloseWaveInDevice(&WInDev[iDevice]);
 379       }
 380     }
 381
 382     arts_free();    /* free up arts */
 383     return 1;
 384 }
 385
 386 /******************************************************************
 387  *              ARTS_WaveInit
 388  *
 389  * Initialize internal structures from ARTS server info
 390  */
 391 LONG ARTS_WaveInit(void)
 392 {
 393     int         i;
 394     int         errorcode;
 395
 396     TRACE("called\n");
 397
 398     if ((errorcode = ARTS_Init()) < 0)
 399     {
 400         WARN("arts_init() failed (%d)\n", errorcode);
 401         return -1;
 402     }
 403
 404     /* initialize all device handles to -1 */
 405     for (i = 0; i < MAX_WAVEOUTDRV; ++i)
 406     {
 407         static const WCHAR ini[] = {'a','R','t','s',' ','W','a','v','e','O','u','t','D','r','i','v','e','r',0};
 408
 409         WOutDev[i].play_stream = (arts_stream_t*)-1;
 410         memset(&WOutDev[i].caps, 0, sizeof(WOutDev[i].caps)); /* zero out
 411                                                         caps values */
 412         WOutDev[i].caps.wMid = 0x00FF;  /* Manufac ID */
 413         WOutDev[i].caps.wPid = 0x0001;  /* Product ID */
 414         strcpyW(WOutDev[i].caps.szPname, ini);
 415         snprintf(WOutDev[i].interface_name, sizeof(WOutDev[i].interface_name), "winearts: %d", i);
 416
 417         WOutDev[i].caps.vDriverVersion = 0x0100;
 418         WOutDev[i].caps.dwFormats = 0x00000000;
 419         WOutDev[i].caps.dwSupport = WAVECAPS_VOLUME;
 420
 421         WOutDev[i].caps.wChannels = 2;
 422         WOutDev[i].caps.dwSupport |= WAVECAPS_LRVOLUME;
 423
 424         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
 425         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S08;
 426         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
 427         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
 428         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
 429         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S08;
 430         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
 431         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
 432         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
 433         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;
 434         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
 435         WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
 436     }
 437
 438     for (i = 0; i < MAX_WAVEINDRV; ++i)
 439     {
 440         static const WCHAR ini[] = {'a','R','t','s',' ','W','a','v','e','I','n',' ','D','r','i','v','e','r',0};
 441
 442         WInDev[i].record_stream = (arts_stream_t*)-1;
 443         memset(&WInDev[i].caps, 0, sizeof(WInDev[i].caps)); /* zero out
 444                                                         caps values */
 445         WInDev[i].caps.wMid = 0x00FF;
 446         WInDev[i].caps.wPid = 0x0001;
 447         strcpyW(WInDev[i].caps.szPname, ini);
 448         snprintf(WInDev[i].interface_name, sizeof(WInDev[i].interface_name), "winearts: %d", i);
 449
 450         WInDev[i].caps.vDriverVersion = 0x0100;
 451         WInDev[i].caps.dwFormats = 0x00000000;
 452
 453         WInDev[i].caps.wChannels = 2;
 454
 455         WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
 456         WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S08;
 457         WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
 458         WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
 459         WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
 460         WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S08;
 461         WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
 462         WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
 463         WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
 464         WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;
 465         WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
 466         WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
 467
 468         WInDev[i].caps.wReserved1 = 0;
 469     }
 470     return 0;
 471 }
 472
 473 /******************************************************************
 474  *              ARTS_InitRingMessage
 475  *
 476  * Initialize the ring of messages for passing between driver's caller and playback/record
 477  * thread
 478  */
 479 static int ARTS_InitRingMessage(ARTS_MSG_RING* mr)
 480 {
 481     mr->msg_toget = 0;
 482     mr->msg_tosave = 0;
 483     mr->msg_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 484     mr->ring_buffer_size = ARTS_RING_BUFFER_INCREMENT;
 485     mr->messages = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,mr->ring_buffer_size * sizeof(RING_MSG));
 486     InitializeCriticalSection(&mr->msg_crst);
 487     return 0;
 488 }
 489
 490 /******************************************************************
 491  *              ARTS_DestroyRingMessage
 492  *
 493  */
 494 static int ARTS_DestroyRingMessage(ARTS_MSG_RING* mr)
 495 {
 496     CloseHandle(mr->msg_event);
 497     HeapFree(GetProcessHeap(),0,mr->messages);
 498     mr->messages=NULL;
 499     DeleteCriticalSection(&mr->msg_crst);
 500     return 0;
 501 }
 502
 503 /******************************************************************
 504  *              ARTS_AddRingMessage
 505  *
 506  * Inserts a new message into the ring (should be called from DriverProc derivated routines)
 507  */
 508 static int ARTS_AddRingMessage(ARTS_MSG_RING* mr, enum win_wm_message msg, DWORD param, BOOL wait)
 509 {
 510     HANDLE      hEvent = INVALID_HANDLE_VALUE;
 511
 512     EnterCriticalSection(&mr->msg_crst);
 513     if ((mr->msg_toget == ((mr->msg_tosave + 1) % mr->ring_buffer_size)))
 514     {
 515         int old_ring_buffer_size = mr->ring_buffer_size;
 516         mr->ring_buffer_size += ARTS_RING_BUFFER_INCREMENT;
 517         TRACE("mr->ring_buffer_size=%d\n",mr->ring_buffer_size);
 518         mr->messages = HeapReAlloc(GetProcessHeap(),0,mr->messages, mr->ring_buffer_size * sizeof(RING_MSG));
 519         /* Now we need to rearrange the ring buffer so that the new
 520            buffers just allocated are in between mr->msg_tosave and
 521            mr->msg_toget.
 522         */
 523         if (mr->msg_tosave < mr->msg_toget)
 524         {
 525             memmove(&(mr->messages[mr->msg_toget + ARTS_RING_BUFFER_INCREMENT]),
 526                     &(mr->messages[mr->msg_toget]),
 527                     sizeof(RING_MSG)*(old_ring_buffer_size - mr->msg_toget)
 528                     );
 529             mr->msg_toget += ARTS_RING_BUFFER_INCREMENT;
 530         }
 531     }
 532     if (wait)
 533     {
 534         hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 535         if (hEvent == INVALID_HANDLE_VALUE)
 536         {
 537             ERR("can't create event !?\n");
 538             LeaveCriticalSection(&mr->msg_crst);
 539             return 0;
 540         }
 541         if (mr->msg_toget != mr->msg_tosave && mr->messages[mr->msg_toget].msg != WINE_WM_HEADER)
 542             FIXME("two fast messages in the queue!!!!\n");
 543
 544         /* fast messages have to be added at the start of the queue */
 545         mr->msg_toget = (mr->msg_toget + mr->ring_buffer_size - 1) % mr->ring_buffer_size;
 546
 547         mr->messages[mr->msg_toget].msg = msg;
 548         mr->messages[mr->msg_toget].param = param;
 549         mr->messages[mr->msg_toget].hEvent = hEvent;
 550     }
 551     else
 552     {
 553         mr->messages[mr->msg_tosave].msg = msg;
 554         mr->messages[mr->msg_tosave].param = param;
 555         mr->messages[mr->msg_tosave].hEvent = INVALID_HANDLE_VALUE;
 556         mr->msg_tosave = (mr->msg_tosave + 1) % mr->ring_buffer_size;
 557     }
 558
 559     LeaveCriticalSection(&mr->msg_crst);
 560
 561     SetEvent(mr->msg_event);    /* signal a new message */
 562
 563     if (wait)
 564     {
 565         /* wait for playback/record thread to have processed the message */
 566         WaitForSingleObject(hEvent, INFINITE);
 567         CloseHandle(hEvent);
 568     }
 569
 570     return 1;
 571 }
 572
 573 /******************************************************************
 574  *              ARTS_RetrieveRingMessage
 575  *
 576  * Get a message from the ring. Should be called by the playback/record thread.
 577  */
 578 static int ARTS_RetrieveRingMessage(ARTS_MSG_RING* mr,
 579                                    enum win_wm_message *msg, DWORD *param, HANDLE *hEvent)
 580 {
 581     EnterCriticalSection(&mr->msg_crst);
 582
 583     if (mr->msg_toget == mr->msg_tosave) /* buffer empty ? */
 584     {
 585         LeaveCriticalSection(&mr->msg_crst);
 586         return 0;
 587     }
 588
 589     *msg = mr->messages[mr->msg_toget].msg;
 590     mr->messages[mr->msg_toget].msg = 0;
 591     *param = mr->messages[mr->msg_toget].param;
 592     *hEvent = mr->messages[mr->msg_toget].hEvent;
 593     mr->msg_toget = (mr->msg_toget + 1) % mr->ring_buffer_size;
 594     LeaveCriticalSection(&mr->msg_crst);
 595     return 1;
 596 }
 597
 598 /*======================================================================*
 599  *                  Low level WAVE OUT implementation                   *
 600  *======================================================================*/
 601
 602 /**************************************************************************
 603  *                      wodNotifyClient                 [internal]
 604  */
 605 static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
 606 {
 607     TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
 608
 609     switch (wMsg) {
 610     case WOM_OPEN:
 611     case WOM_CLOSE:
 612     case WOM_DONE:
 613         if (wwo->wFlags != DCB_NULL &&
 614             !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, (HDRVR)wwo->waveDesc.hWave,
 615                             wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
 616             WARN("can't notify client !\n");
 617             return MMSYSERR_ERROR;
 618         }
 619         break;
 620     default:
 621         FIXME("Unknown callback message %u\n", wMsg);
 622         return MMSYSERR_INVALPARAM;
 623     }
 624     return MMSYSERR_NOERROR;
 625 }
 626
 627 /**************************************************************************
 628  *                              wodUpdatePlayedTotal    [internal]
 629  *
 630  */
 631 static BOOL wodUpdatePlayedTotal(WINE_WAVEOUT* wwo)
 632 {
 633     /* total played is the bytes written less the bytes to write ;-) */
 634     wwo->dwPlayedTotal = wwo->dwWrittenTotal -
 635         (wwo->dwBufferSize -
 636         arts_stream_get(wwo->play_stream, ARTS_P_BUFFER_SPACE));
 637
 638     return TRUE;
 639 }
 640
 641 /**************************************************************************
 642  *                              wodPlayer_BeginWaveHdr          [internal]
 643  *
 644  * Makes the specified lpWaveHdr the currently playing wave header.
 645  * If the specified wave header is a begin loop and we're not already in
 646  * a loop, setup the loop.
 647  */
 648 static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
 649 {
 650     wwo->lpPlayPtr = lpWaveHdr;
 651
 652     if (!lpWaveHdr) return;
 653
 654     if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
 655         if (wwo->lpLoopPtr) {
 656             WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
 657             TRACE("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
 658         } else {
 659             TRACE("Starting loop (%ldx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
 660             wwo->lpLoopPtr = lpWaveHdr;
 661             /* Windows does not touch WAVEHDR.dwLoops,
 662              * so we need to make an internal copy */
 663             wwo->dwLoops = lpWaveHdr->dwLoops;
 664         }
 665     }
 666     wwo->dwPartialOffset = 0;
 667 }
 668
 669 /**************************************************************************
 670  *                              wodPlayer_PlayPtrNext           [internal]
 671  *
 672  * Advance the play pointer to the next waveheader, looping if required.
 673  */
 674 static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEOUT* wwo)
 675 {
 676     LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
 677
 678     wwo->dwPartialOffset = 0;
 679     if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
 680         /* We're at the end of a loop, loop if required */
 681         if (--wwo->dwLoops > 0) {
 682             wwo->lpPlayPtr = wwo->lpLoopPtr;
 683         } else {
 684             /* Handle overlapping loops correctly */
 685             if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
 686                 FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
 687                 /* shall we consider the END flag for the closing loop or for
 688                  * the opening one or for both ???
 689                  * code assumes for closing loop only
 690                  */
 691             } else {
 692                 lpWaveHdr = lpWaveHdr->lpNext;
 693             }
 694             wwo->lpLoopPtr = NULL;
 695             wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
 696         }
 697     } else {
 698         /* We're not in a loop.  Advance to the next wave header */
 699         wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
 700     }
 701
 702     return lpWaveHdr;
 703 }
 704
 705 /**************************************************************************
 706  *                           wodPlayer_NotifyWait               [internal]
 707  * Returns the number of milliseconds to wait before attempting to notify
 708  * completion of the specified wavehdr.
 709  * This is based on the number of bytes remaining to be written in the
 710  * wave.
 711  */
 712 static DWORD wodPlayer_NotifyWait(const WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
 713 {
 714     DWORD dwMillis;
 715
 716     if(lpWaveHdr->reserved < wwo->dwPlayedTotal)
 717     {
 718         dwMillis = 1;
 719     }
 720     else
 721     {
 722         dwMillis = (lpWaveHdr->reserved - wwo->dwPlayedTotal) * 1000 / wwo->format.wf.nAvgBytesPerSec;
 723         if(!dwMillis) dwMillis = 1;
 724     }
 725
 726     TRACE("dwMillis = %ld\n", dwMillis);
 727
 728     return dwMillis;
 729 }
 730
 731
 732 /**************************************************************************
 733  *                           wodPlayer_WriteMaxFrags            [internal]
 734  * Writes the maximum number of bytes possible to the DSP and returns
 735  * the number of bytes written.
 736  */
 737 static int wodPlayer_WriteMaxFrags(WINE_WAVEOUT* wwo, DWORD* bytes)
 738 {
 739     /* Only attempt to write to free bytes */
 740     DWORD dwLength = wwo->lpPlayPtr->dwBufferLength - wwo->dwPartialOffset;
 741     int toWrite = min(dwLength, *bytes);
 742     int written;
 743
 744     TRACE("Writing wavehdr %p.%lu[%lu]\n",
 745           wwo->lpPlayPtr, wwo->dwPartialOffset, wwo->lpPlayPtr->dwBufferLength);
 746
 747     if (dwLength == 0)
 748     {
 749         wodPlayer_PlayPtrNext(wwo);
 750         return 0;
 751     }
 752
 753     /* see if our buffer isn't large enough for the data we are writing */
 754     if(wwo->buffer_size < toWrite)
 755     {
 756       if(wwo->sound_buffer)
 757       {
 758         wwo->sound_buffer = HeapReAlloc(GetProcessHeap(), 0, wwo->sound_buffer, toWrite);
 759         wwo->buffer_size = toWrite;
 760       }
 761     }
 762
 763     /* if we don't have a buffer then get one */
 764     if(!wwo->sound_buffer)
 765     {
 766       /* allocate some memory for the buffer */
 767       wwo->sound_buffer = HeapAlloc(GetProcessHeap(), 0, toWrite);
 768       wwo->buffer_size = toWrite;
 769     }
 770
 771     /* if we don't have a buffer then error out */
 772     if(!wwo->sound_buffer)
 773     {
 774       ERR("error allocating sound_buffer memory\n");
 775       return 0;
 776     }
 777
 778     TRACE("toWrite == %d\n", toWrite);
 779
 780     /* apply volume to the bits */
 781     /* for single channel audio streams we only use the LEFT volume */
 782     if(wwo->format.wBitsPerSample == 16)
 783     {
 784       /* apply volume to the buffer we are about to send */
 785       /* divide toWrite(bytes) by 2 as volume processes by 16 bits */
 786       volume_effect16(wwo->lpPlayPtr->lpData + wwo->dwPartialOffset,
 787                 wwo->sound_buffer, toWrite>>1, wwo->volume_left,
 788                 wwo->volume_right, wwo->format.wf.nChannels);
 789     } else if(wwo->format.wBitsPerSample == 8)
 790     {
 791       /* apply volume to the buffer we are about to send */
 792       volume_effect8(wwo->lpPlayPtr->lpData + wwo->dwPartialOffset,
 793                 wwo->sound_buffer, toWrite, wwo->volume_left,
 794                 wwo->volume_right, wwo->format.wf.nChannels);
 795     } else
 796     {
 797       FIXME("unsupported wwo->format.wBitsPerSample of %d\n",
 798         wwo->format.wBitsPerSample);
 799     }
 800
 801     /* send the audio data to arts for playing */
 802     written = arts_write(wwo->play_stream, wwo->sound_buffer, toWrite);
 803
 804     TRACE("written = %d\n", written);
 805
 806     if (written <= 0)
 807     {
 808       *bytes = 0; /* apparently arts is actually full */
 809       return written; /* if we wrote nothing just return */
 810     }
 811
 812     if (written >= dwLength)
 813         wodPlayer_PlayPtrNext(wwo);   /* If we wrote all current wavehdr, skip to the next one */
 814     else
 815         wwo->dwPartialOffset += written;    /* Remove the amount written */
 816
 817     if (written < toWrite)
 818         *bytes = 0;
 819     else
 820         *bytes -= written;
 821
 822     wwo->dwWrittenTotal += written; /* update stats on this wave device */
 823
 824     return written; /* return the number of bytes written */
 825 }
 826
 827
 828 /**************************************************************************
 829  *                              wodPlayer_NotifyCompletions     [internal]
 830  *
 831  * Notifies and remove from queue all wavehdrs which have been played to
 832  * the speaker (ie. they have cleared the audio device).  If force is true,
 833  * we notify all wavehdrs and remove them all from the queue even if they
 834  * are unplayed or part of a loop.
 835  */
 836 static DWORD wodPlayer_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
 837 {
 838     LPWAVEHDR           lpWaveHdr;
 839
 840     if (wwo->lpQueuePtr) {
 841         TRACE("lpWaveHdr=(%p), lpPlayPtr=(%p), lpLoopPtr=(%p), reserved=(%ld), dwWrittenTotal=(%ld), force=(%d)\n",
 842               wwo->lpQueuePtr,
 843               wwo->lpPlayPtr,
 844               wwo->lpLoopPtr,
 845               wwo->lpQueuePtr->reserved,
 846               wwo->dwWrittenTotal,
 847               force);
 848     } else {
 849         TRACE("lpWaveHdr=(%p), lpPlayPtr=(%p), lpLoopPtr=(%p),  dwWrittenTotal=(%ld), force=(%d)\n",
 850               wwo->lpQueuePtr,
 851               wwo->lpPlayPtr,
 852               wwo->lpLoopPtr,
 853               wwo->dwWrittenTotal,
 854               force);
 855     }
 856
 857     /* Start from lpQueuePtr and keep notifying until:
 858      * - we hit an unwritten wavehdr
 859      * - we hit the beginning of a running loop
 860      * - we hit a wavehdr which hasn't finished playing
 861      */
 862     while ((lpWaveHdr = wwo->lpQueuePtr) &&
 863            (force ||
 864             (lpWaveHdr != wwo->lpPlayPtr &&
 865              lpWaveHdr != wwo->lpLoopPtr &&
 866              lpWaveHdr->reserved <= wwo->dwWrittenTotal))) {
 867
 868         wwo->lpQueuePtr = lpWaveHdr->lpNext;
 869
 870         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
 871         lpWaveHdr->dwFlags |= WHDR_DONE;
 872
 873         wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
 874     }
 875     return  (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != wwo->lpLoopPtr) ?
 876         wodPlayer_NotifyWait(wwo, lpWaveHdr) : INFINITE;
 877 }
 878
 879 /**************************************************************************
 880  *                              wodPlayer_Reset                 [internal]
 881  *
 882  * wodPlayer helper. Resets current output stream.
 883  */
 884 static  void    wodPlayer_Reset(WINE_WAVEOUT* wwo, BOOL reset)
 885 {
 886     wodUpdatePlayedTotal(wwo);
 887
 888     wodPlayer_NotifyCompletions(wwo, FALSE); /* updates current notify list */
 889
 890     /* we aren't able to flush any data that has already been written */
 891     /* to arts, otherwise we would do the flushing here */
 892
 893     if (reset) {
 894         enum win_wm_message     msg;
 895         DWORD                   param;
 896         HANDLE                  ev;
 897
 898         /* remove any buffer */
 899         wodPlayer_NotifyCompletions(wwo, TRUE);
 900
 901         wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
 902         wwo->state = WINE_WS_STOPPED;
 903         wwo->dwPlayedTotal = wwo->dwWrittenTotal = 0;
 904
 905         wwo->dwPartialOffset = 0;        /* Clear partial wavehdr */
 906
 907         /* remove any existing message in the ring */
 908         EnterCriticalSection(&wwo->msgRing.msg_crst);
 909
 910         /* return all pending headers in queue */
 911         while (ARTS_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev))
 912         {
 913             TRACE("flushing msg\n");
 914             if (msg != WINE_WM_HEADER)
 915             {
 916                 FIXME("shouldn't have headers left\n");
 917                 SetEvent(ev);
 918                 continue;
 919             }
 920             ((LPWAVEHDR)param)->dwFlags &= ~WHDR_INQUEUE;
 921             ((LPWAVEHDR)param)->dwFlags |= WHDR_DONE;
 922
 923             wodNotifyClient(wwo, WOM_DONE, param, 0);
 924         }
 925         ResetEvent(wwo->msgRing.msg_event);
 926         LeaveCriticalSection(&wwo->msgRing.msg_crst);
 927     } else {
 928         if (wwo->lpLoopPtr) {
 929             /* complicated case, not handled yet (could imply modifying the loop counter */
 930             FIXME("Pausing while in loop isn't correctly handled yet, except strange results\n");
 931             wwo->lpPlayPtr = wwo->lpLoopPtr;
 932             wwo->dwPartialOffset = 0;
 933             wwo->dwWrittenTotal = wwo->dwPlayedTotal; /* this is wrong !!! */
 934         } else {
 935             /* the data already written is going to be played, so take */
 936             /* this fact into account here */
 937             wwo->dwPlayedTotal = wwo->dwWrittenTotal;
 938         }
 939         wwo->state = WINE_WS_PAUSED;
 940     }
 941 }
 942
 943 /**************************************************************************
 944  *                    wodPlayer_ProcessMessages                 [internal]
 945  */
 946 static void wodPlayer_ProcessMessages(WINE_WAVEOUT* wwo)
 947 {
 948     LPWAVEHDR           lpWaveHdr;
 949     enum win_wm_message msg;
 950     DWORD               param;
 951     HANDLE              ev;
 952
 953     while (ARTS_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev)) {
 954         TRACE("Received %s %lx\n", wodPlayerCmdString[msg - WM_USER - 1], param);
 955         switch (msg) {
 956         case WINE_WM_PAUSING:
 957             wodPlayer_Reset(wwo, FALSE);
 958             SetEvent(ev);
 959             break;
 960         case WINE_WM_RESTARTING:
 961             wwo->state = WINE_WS_PLAYING;
 962             SetEvent(ev);
 963             break;
 964         case WINE_WM_HEADER:
 965             lpWaveHdr = (LPWAVEHDR)param;
 966
 967             /* insert buffer at the end of queue */
 968             {
 969                 LPWAVEHDR*      wh;
 970                 for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
 971                 *wh = lpWaveHdr;
 972             }
 973             if (!wwo->lpPlayPtr)
 974                 wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
 975             if (wwo->state == WINE_WS_STOPPED)
 976                 wwo->state = WINE_WS_PLAYING;
 977             break;
 978         case WINE_WM_RESETTING:
 979             wodPlayer_Reset(wwo, TRUE);
 980             SetEvent(ev);
 981             break;
 982         case WINE_WM_UPDATE:
 983             wodUpdatePlayedTotal(wwo);
 984             SetEvent(ev);
 985             break;
 986         case WINE_WM_BREAKLOOP:
 987             if (wwo->state == WINE_WS_PLAYING && wwo->lpLoopPtr != NULL) {
 988                 /* ensure exit at end of current loop */
 989                 wwo->dwLoops = 1;
 990             }
 991             SetEvent(ev);
 992             break;
 993         case WINE_WM_CLOSING:
 994             /* sanity check: this should not happen since the device must have been reset before */
 995             if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
 996             wwo->hThread = 0;
 997             wwo->state = WINE_WS_CLOSED;
 998             SetEvent(ev);
 999             ExitThread(0);
1000             /* shouldn't go here */
1001         default:
1002             FIXME("unknown message %d\n", msg);
1003             break;
1004         }
1005     }
1006 }
1007
1008 /**************************************************************************
1009  *                           wodPlayer_FeedDSP                  [internal]
1010  * Feed as much sound data as we can into the DSP and return the number of
1011  * milliseconds before it will be necessary to feed the DSP again.
1012  */
1013 static DWORD wodPlayer_FeedDSP(WINE_WAVEOUT* wwo)
1014 {
1015     DWORD       availInQ;
1016
1017     wodUpdatePlayedTotal(wwo);
1018     availInQ = arts_stream_get(wwo->play_stream, ARTS_P_BUFFER_SPACE);
1019     TRACE("availInQ = %ld\n", availInQ);
1020
1021     /* input queue empty */
1022     if (!wwo->lpPlayPtr) {
1023         TRACE("Run out of wavehdr:s... flushing\n");
1024         return INFINITE;
1025     }
1026
1027     /* no more room... no need to try to feed */
1028     if(!availInQ)
1029     {
1030         TRACE("no more room, no need to try to feed\n");
1031         return wwo->dwSleepTime;
1032     }
1033
1034     /* Feed from partial wavehdr */
1035     if (wwo->lpPlayPtr && wwo->dwPartialOffset != 0)
1036     {
1037         TRACE("feeding from partial wavehdr\n");
1038         wodPlayer_WriteMaxFrags(wwo, &availInQ);
1039     }
1040
1041     /* Feed wavehdrs until we run out of wavehdrs or DSP space */
1042     if (!wwo->dwPartialOffset)
1043     {
1044         while(wwo->lpPlayPtr && availInQ)
1045         {
1046             TRACE("feeding waveheaders until we run out of space\n");
1047             /* note the value that dwPlayedTotal will return when this wave finishes playing */
1048             wwo->lpPlayPtr->reserved = wwo->dwWrittenTotal + wwo->lpPlayPtr->dwBufferLength;
1049             TRACE("reserved=(%ld) dwWrittenTotal=(%ld) dwBufferLength=(%ld)\n",
1050                   wwo->lpPlayPtr->reserved,
1051                   wwo->dwWrittenTotal,
1052                   wwo->lpPlayPtr->dwBufferLength
1053                 );
1054             wodPlayer_WriteMaxFrags(wwo, &availInQ);
1055         }
1056     }
1057
1058     if (!wwo->lpPlayPtr) {
1059         TRACE("Ran out of wavehdrs\n");
1060         return INFINITE;
1061     }
1062
1063     return wwo->dwSleepTime;
1064 }
1065
1066
1067 /**************************************************************************
1068  *                              wodPlayer                       [internal]
1069  */
1070 static  DWORD   CALLBACK        wodPlayer(LPVOID pmt)
1071 {
1072     WORD          uDevID = (DWORD)pmt;
1073     WINE_WAVEOUT* wwo = (WINE_WAVEOUT*)&WOutDev[uDevID];
1074     DWORD         dwNextFeedTime = INFINITE;   /* Time before DSP needs feeding */
1075     DWORD         dwNextNotifyTime = INFINITE; /* Time before next wave completion */
1076     DWORD         dwSleepTime;
1077
1078     wwo->state = WINE_WS_STOPPED;
1079     SetEvent(wwo->hStartUpEvent);
1080
1081     for (;;) {
1082         /** Wait for the shortest time before an action is required.  If there
1083          *  are no pending actions, wait forever for a command.
1084          */
1085         dwSleepTime = min(dwNextFeedTime, dwNextNotifyTime);
1086         TRACE("waiting %lums (%lu,%lu)\n", dwSleepTime, dwNextFeedTime, dwNextNotifyTime);
1087         WaitForSingleObject(wwo->msgRing.msg_event, dwSleepTime);
1088         wodPlayer_ProcessMessages(wwo);
1089         if (wwo->state == WINE_WS_PLAYING) {
1090             dwNextFeedTime = wodPlayer_FeedDSP(wwo);
1091             dwNextNotifyTime = wodPlayer_NotifyCompletions(wwo, FALSE);
1092         } else {
1093             dwNextFeedTime = dwNextNotifyTime = INFINITE;
1094         }
1095     }
1096 }
1097
1098 /**************************************************************************
1099  *                      wodGetDevCaps                           [internal]
1100  */
1101 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSW lpCaps, DWORD dwSize)
1102 {
1103     TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
1104
1105     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1106
1107     if (wDevID >= MAX_WAVEOUTDRV) {
1108         TRACE("MAX_WAVOUTDRV reached !\n");
1109         return MMSYSERR_BADDEVICEID;
1110     }
1111
1112     memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1113     return MMSYSERR_NOERROR;
1114 }
1115
1116 /**************************************************************************
1117  *                              wodOpen                         [internal]
1118  */
1119 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1120 {
1121     WINE_WAVEOUT*       wwo;
1122
1123     TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
1124     if (lpDesc == NULL) {
1125         WARN("Invalid Parameter !\n");
1126         return MMSYSERR_INVALPARAM;
1127     }
1128     if (wDevID >= MAX_WAVEOUTDRV) {
1129         TRACE("MAX_WAVOUTDRV reached !\n");
1130         return MMSYSERR_BADDEVICEID;
1131     }
1132
1133     /* if this device is already open tell the app that it is allocated */
1134     if(WOutDev[wDevID].play_stream != (arts_stream_t*)-1)
1135     {
1136       TRACE("device already allocated\n");
1137       return MMSYSERR_ALLOCATED;
1138     }
1139
1140     /* only PCM format is supported so far... */
1141     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1142         lpDesc->lpFormat->nChannels == 0 ||
1143         lpDesc->lpFormat->nSamplesPerSec < DSBFREQUENCY_MIN ||
1144         lpDesc->lpFormat->nSamplesPerSec > DSBFREQUENCY_MAX ||
1145         (lpDesc->lpFormat->wBitsPerSample!=8 && lpDesc->lpFormat->wBitsPerSample!=16)) {
1146         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1147              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1148              lpDesc->lpFormat->nSamplesPerSec);
1149         return WAVERR_BADFORMAT;
1150     }
1151
1152     if (dwFlags & WAVE_FORMAT_QUERY) {
1153         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1154              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1155              lpDesc->lpFormat->nSamplesPerSec);
1156         return MMSYSERR_NOERROR;
1157     }
1158
1159     wwo = &WOutDev[wDevID];
1160
1161     /* direct sound not supported, ignore the flag */
1162     dwFlags &= ~WAVE_DIRECTSOUND;
1163
1164     wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1165
1166     memcpy(&wwo->waveDesc, lpDesc,           sizeof(WAVEOPENDESC));
1167     memcpy(&wwo->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
1168
1169     if (wwo->format.wBitsPerSample == 0) {
1170         WARN("Resetting zeroed wBitsPerSample\n");
1171         wwo->format.wBitsPerSample = 8 *
1172             (wwo->format.wf.nAvgBytesPerSec /
1173              wwo->format.wf.nSamplesPerSec) /
1174             wwo->format.wf.nChannels;
1175     }
1176
1177     wwo->play_stream = arts_play_stream(wwo->format.wf.nSamplesPerSec,
1178         wwo->format.wBitsPerSample, wwo->format.wf.nChannels, "winearts");
1179
1180     /* clear these so we don't have any confusion ;-) */
1181     wwo->sound_buffer = 0;
1182     wwo->buffer_size = 0;
1183
1184     arts_stream_set(wwo->play_stream, ARTS_P_BLOCKING, 0);    /* disable blocking on this stream */
1185
1186     if(!wwo->play_stream) return MMSYSERR_ALLOCATED;
1187
1188     /* Try to set the packet settings from constant and store the value that it
1189        was actually set to for future use */
1190     wwo->packetSettings = arts_stream_set(wwo->play_stream, ARTS_P_PACKET_SETTINGS, WAVEOUT_PACKET_SETTINGS);
1191     TRACE("Tried to set ARTS_P_PACKET_SETTINGS to (%x), actually set to (%x)\n", WAVEOUT_PACKET_SETTINGS, wwo->packetSettings);
1192
1193     wwo->dwBufferSize = arts_stream_get(wwo->play_stream, ARTS_P_BUFFER_SIZE);
1194     TRACE("Buffer size is now (%ld)\n",wwo->dwBufferSize);
1195
1196     wwo->dwPlayedTotal = 0;
1197     wwo->dwWrittenTotal = 0;
1198
1199     wwo->dwSleepTime = ((1 << (wwo->packetSettings & 0xFFFF)) * 1000 * BUFFER_REFILL_THRESHOLD) / wwo->format.wf.nAvgBytesPerSec;
1200
1201     /* Initialize volume to full level */
1202     wwo->volume_left = 100;
1203     wwo->volume_right = 100;
1204
1205     ARTS_InitRingMessage(&wwo->msgRing);
1206
1207     /* create player thread */
1208     if (!(dwFlags & WAVE_DIRECTSOUND)) {
1209         wwo->hStartUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1210         wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD)wDevID, 0, &(wwo->dwThreadID));
1211         WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
1212         CloseHandle(wwo->hStartUpEvent);
1213     } else {
1214         wwo->hThread = INVALID_HANDLE_VALUE;
1215         wwo->dwThreadID = 0;
1216     }
1217     wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
1218
1219     TRACE("stream=0x%lx, dwBufferSize=%ld\n",
1220           (long)wwo->play_stream, wwo->dwBufferSize);
1221
1222     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n",
1223           wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec,
1224           wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1225           wwo->format.wf.nBlockAlign);
1226
1227     return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
1228 }
1229
1230 /**************************************************************************
1231  *                              wodClose                        [internal]
1232  */
1233 static DWORD wodClose(WORD wDevID)
1234 {
1235     DWORD               ret = MMSYSERR_NOERROR;
1236     WINE_WAVEOUT*       wwo;
1237
1238     TRACE("(%u);\n", wDevID);
1239
1240     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].play_stream  ==
1241         (arts_stream_t*)-1)
1242     {
1243         WARN("bad device ID !\n");
1244         return MMSYSERR_BADDEVICEID;
1245     }
1246
1247     wwo = &WOutDev[wDevID];
1248     if (wwo->lpQueuePtr) {
1249         WARN("buffers still playing !\n");
1250         ret = WAVERR_STILLPLAYING;
1251     } else {
1252         TRACE("imhere[3-close]\n");
1253         if (wwo->hThread != INVALID_HANDLE_VALUE) {
1254             ARTS_AddRingMessage(&wwo->msgRing, WINE_WM_CLOSING, 0, TRUE);
1255         }
1256
1257         ARTS_DestroyRingMessage(&wwo->msgRing);
1258
1259         ARTS_CloseWaveOutDevice(wwo);   /* close the stream and clean things up */
1260
1261         ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
1262     }
1263     return ret;
1264 }
1265
1266 /**************************************************************************
1267  *                              wodWrite                        [internal]
1268  *
1269  */
1270 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1271 {
1272     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1273
1274     /* first, do the sanity checks... */
1275     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].play_stream ==
1276                 (arts_stream_t*)-1)
1277     {
1278         WARN("bad dev ID !\n");
1279         return MMSYSERR_BADDEVICEID;
1280     }
1281
1282     if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
1283     {
1284         TRACE("unprepared\n");
1285         return WAVERR_UNPREPARED;
1286     }
1287
1288     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1289     {
1290         TRACE("still playing\n");
1291         return WAVERR_STILLPLAYING;
1292     }
1293
1294     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1295     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1296     lpWaveHdr->lpNext = 0;
1297
1298     TRACE("adding ring message\n");
1299     ARTS_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
1300
1301     return MMSYSERR_NOERROR;
1302 }
1303
1304 /**************************************************************************
1305  *                              wodPrepare                      [internal]
1306  */
1307 static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1308 {
1309     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1310
1311     if (wDevID >= MAX_WAVEOUTDRV) {
1312         WARN("bad device ID !\n");
1313         return MMSYSERR_BADDEVICEID;
1314     }
1315
1316     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1317         return WAVERR_STILLPLAYING;
1318
1319     lpWaveHdr->dwFlags |= WHDR_PREPARED;
1320     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1321     return MMSYSERR_NOERROR;
1322 }
1323
1324 /**************************************************************************
1325  *                              wodUnprepare                    [internal]
1326  */
1327 static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1328 {
1329     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1330
1331     if (wDevID >= MAX_WAVEOUTDRV) {
1332         WARN("bad device ID !\n");
1333         return MMSYSERR_BADDEVICEID;
1334     }
1335
1336     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1337         return WAVERR_STILLPLAYING;
1338
1339     lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
1340     lpWaveHdr->dwFlags |= WHDR_DONE;
1341
1342     return MMSYSERR_NOERROR;
1343 }
1344
1345 /**************************************************************************
1346  *                      wodPause                                [internal]
1347  */
1348 static DWORD wodPause(WORD wDevID)
1349 {
1350     TRACE("(%u);!\n", wDevID);
1351
1352     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].play_stream ==
1353                 (arts_stream_t*)-1)
1354     {
1355         WARN("bad device ID !\n");
1356         return MMSYSERR_BADDEVICEID;
1357     }
1358
1359     TRACE("imhere[3-PAUSING]\n");
1360     ARTS_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_PAUSING, 0, TRUE);
1361
1362     return MMSYSERR_NOERROR;
1363 }
1364
1365 /**************************************************************************
1366  *                      wodRestart                              [internal]
1367  */
1368 static DWORD wodRestart(WORD wDevID)
1369 {
1370     TRACE("(%u);\n", wDevID);
1371
1372     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].play_stream ==
1373                 (arts_stream_t*)-1)
1374     {
1375         WARN("bad device ID !\n");
1376         return MMSYSERR_BADDEVICEID;
1377     }
1378
1379     if (WOutDev[wDevID].state == WINE_WS_PAUSED) {
1380         TRACE("imhere[3-RESTARTING]\n");
1381         ARTS_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESTARTING, 0, TRUE);
1382     }
1383
1384     /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
1385     /* FIXME: Myst crashes with this ... hmm -MM
1386        return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
1387     */
1388
1389     return MMSYSERR_NOERROR;
1390 }
1391
1392 /**************************************************************************
1393  *                      wodReset                                [internal]
1394  */
1395 static DWORD wodReset(WORD wDevID)
1396 {
1397     TRACE("(%u);\n", wDevID);
1398
1399     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].play_stream ==
1400         (arts_stream_t*)-1)
1401     {
1402         WARN("bad device ID !\n");
1403         return MMSYSERR_BADDEVICEID;
1404     }
1405
1406     TRACE("imhere[3-RESET]\n");
1407     ARTS_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
1408
1409     return MMSYSERR_NOERROR;
1410 }
1411
1412 /**************************************************************************
1413  *                              wodGetPosition                  [internal]
1414  */
1415 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1416 {
1417     WINE_WAVEOUT*       wwo;
1418
1419     TRACE("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
1420
1421     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].play_stream ==
1422         (arts_stream_t*)-1)
1423     {
1424         WARN("bad device ID !\n");
1425         return MMSYSERR_BADDEVICEID;
1426     }
1427
1428     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1429
1430     wwo = &WOutDev[wDevID];
1431     ARTS_AddRingMessage(&wwo->msgRing, WINE_WM_UPDATE, 0, TRUE);
1432
1433     return bytes_to_mmtime(lpTime, wwo->dwPlayedTotal, &wwo->format);
1434 }
1435
1436 /**************************************************************************
1437  *                              wodBreakLoop                    [internal]
1438  */
1439 static DWORD wodBreakLoop(WORD wDevID)
1440 {
1441     TRACE("(%u);\n", wDevID);
1442
1443     if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].play_stream ==
1444                 (arts_stream_t*)-1)
1445     {
1446         WARN("bad device ID !\n");
1447         return MMSYSERR_BADDEVICEID;
1448     }
1449     ARTS_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_BREAKLOOP, 0, TRUE);
1450     return MMSYSERR_NOERROR;
1451 }
1452
1453 /**************************************************************************
1454  *                              wodGetVolume                    [internal]
1455  */
1456 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1457 {
1458     DWORD left, right;
1459
1460     left = WOutDev[wDevID].volume_left;
1461     right = WOutDev[wDevID].volume_right;
1462
1463     TRACE("(%u, %p);\n", wDevID, lpdwVol);
1464
1465     *lpdwVol = ((left * 0xFFFFl) / 100) + (((right * 0xFFFFl) / 100) <<
1466                 16);
1467
1468     return MMSYSERR_NOERROR;
1469 }
1470
1471 /**************************************************************************
1472  *                              wodSetVolume                    [internal]
1473  */
1474 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1475 {
1476     DWORD left, right;
1477
1478     left  = (LOWORD(dwParam) * 100) / 0xFFFFl;
1479     right = (HIWORD(dwParam) * 100) / 0xFFFFl;
1480
1481     TRACE("(%u, %08lX);\n", wDevID, dwParam);
1482
1483     WOutDev[wDevID].volume_left = left;
1484     WOutDev[wDevID].volume_right = right;
1485
1486     return MMSYSERR_NOERROR;
1487 }
1488
1489 /**************************************************************************
1490  *                              wodGetNumDevs                   [internal]
1491  */
1492 static  DWORD   wodGetNumDevs(void)
1493 {
1494     return MAX_WAVEOUTDRV;
1495 }
1496
1497 /**************************************************************************
1498  *                              wodDevInterfaceSize             [internal]
1499  */
1500 static DWORD wodDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
1501 {
1502     TRACE("(%u, %p)\n", wDevID, dwParam1);
1503
1504     *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1505                                     NULL, 0 ) * sizeof(WCHAR);
1506     return MMSYSERR_NOERROR;
1507 }
1508
1509 /**************************************************************************
1510  *                              wodDevInterface                 [internal]
1511  */
1512 static DWORD wodDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
1513 {
1514     if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1515                                         NULL, 0 ) * sizeof(WCHAR))
1516     {
1517         MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1518                             dwParam1, dwParam2 / sizeof(WCHAR));
1519         return MMSYSERR_NOERROR;
1520     }
1521     return MMSYSERR_INVALPARAM;
1522 }
1523
1524 /**************************************************************************
1525  *                              wodMessage (WINEARTS.@)
1526  */
1527 DWORD WINAPI ARTS_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1528                             DWORD dwParam1, DWORD dwParam2)
1529 {
1530     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
1531           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1532
1533     switch (wMsg) {
1534     case DRVM_INIT:
1535     case DRVM_EXIT:
1536     case DRVM_ENABLE:
1537     case DRVM_DISABLE:
1538         /* FIXME: Pretend this is supported */
1539         return 0;
1540     case WODM_OPEN:             return wodOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,      dwParam2);
1541     case WODM_CLOSE:            return wodClose         (wDevID);
1542     case WODM_WRITE:            return wodWrite         (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1543     case WODM_PAUSE:            return wodPause         (wDevID);
1544     case WODM_GETPOS:           return wodGetPosition   (wDevID, (LPMMTIME)dwParam1,            dwParam2);
1545     case WODM_BREAKLOOP:        return wodBreakLoop     (wDevID);
1546     case WODM_PREPARE:          return wodPrepare       (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1547     case WODM_UNPREPARE:        return wodUnprepare     (wDevID, (LPWAVEHDR)dwParam1,           dwParam2);
1548     case WODM_GETDEVCAPS:       return wodGetDevCaps    (wDevID, (LPWAVEOUTCAPSW)dwParam1,      dwParam2);
1549     case WODM_GETNUMDEVS:       return wodGetNumDevs    ();
1550     case WODM_GETPITCH:         return MMSYSERR_NOTSUPPORTED;
1551     case WODM_SETPITCH:         return MMSYSERR_NOTSUPPORTED;
1552     case WODM_GETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1553     case WODM_SETPLAYBACKRATE:  return MMSYSERR_NOTSUPPORTED;
1554     case WODM_GETVOLUME:        return wodGetVolume     (wDevID, (LPDWORD)dwParam1);
1555     case WODM_SETVOLUME:        return wodSetVolume     (wDevID, dwParam1);
1556     case WODM_RESTART:          return wodRestart       (wDevID);
1557     case WODM_RESET:            return wodReset         (wDevID);
1558
1559     case DRV_QUERYDEVICEINTERFACESIZE: return wodDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
1560     case DRV_QUERYDEVICEINTERFACE:     return wodDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
1561     case DRV_QUERYDSOUNDIFACE:  return wodDsCreate      (wDevID, (PIDSDRIVER*)dwParam1);
1562     case DRV_QUERYDSOUNDDESC:   return wodDsDesc        (wDevID, (PDSDRIVERDESC)dwParam1);
1563     default:
1564         FIXME("unknown message %d!\n", wMsg);
1565     }
1566     return MMSYSERR_NOTSUPPORTED;
1567 }
1568
1569 /*======================================================================*
1570  *                  Low level WAVE IN implementation                    *
1571  *======================================================================*/
1572
1573 /**************************************************************************
1574  *                              widGetNumDevs                   [internal]
1575  */
1576 static  DWORD   widGetNumDevs(void)
1577 {
1578     TRACE("%d \n",MAX_WAVEINDRV);
1579     return MAX_WAVEINDRV;
1580 }
1581
1582 /**************************************************************************
1583  *                              widDevInterfaceSize             [internal]
1584  */
1585 static DWORD widDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
1586 {
1587     TRACE("(%u, %p)\n", wDevID, dwParam1);
1588
1589
1590     *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
1591                                     NULL, 0 ) * sizeof(WCHAR);
1592     return MMSYSERR_NOERROR;
1593 }
1594
1595 /**************************************************************************
1596  *                              widDevInterface                 [internal]
1597  */
1598 static DWORD widDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
1599 {
1600     if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
1601                                         NULL, 0 ) * sizeof(WCHAR))
1602     {
1603         MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
1604                             dwParam1, dwParam2 / sizeof(WCHAR));
1605         return MMSYSERR_NOERROR;
1606     }
1607     return MMSYSERR_INVALPARAM;
1608 }
1609
1610 /**************************************************************************
1611  *                      widNotifyClient                 [internal]
1612  */
1613 static DWORD widNotifyClient(WINE_WAVEIN* wwi, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
1614 {
1615     TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
1616
1617     switch (wMsg) {
1618     case WIM_OPEN:
1619     case WIM_CLOSE:
1620     case WIM_DATA:
1621         if (wwi->wFlags != DCB_NULL &&
1622             !DriverCallback(wwi->waveDesc.dwCallback, wwi->wFlags,
1623                             (HDRVR)wwi->waveDesc.hWave, wMsg,
1624                             wwi->waveDesc.dwInstance, dwParam1, dwParam2)) {
1625             WARN("can't notify client !\n");
1626             return MMSYSERR_ERROR;
1627         }
1628         break;
1629     default:
1630         FIXME("Unknown callback message %u\n", wMsg);
1631         return MMSYSERR_INVALPARAM;
1632     }
1633     return MMSYSERR_NOERROR;
1634 }
1635
1636 /**************************************************************************
1637  *                      widGetDevCaps                           [internal]
1638  */
1639 static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPSW lpCaps, DWORD dwSize)
1640 {
1641     TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
1642
1643     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1644
1645     if (wDevID >= MAX_WAVEINDRV) {
1646         TRACE("MAX_WAVINDRV reached !\n");
1647         return MMSYSERR_BADDEVICEID;
1648     }
1649
1650     memcpy(lpCaps, &WInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1651     return MMSYSERR_NOERROR;
1652 }
1653
1654 /**************************************************************************
1655  *                              widRecorder                     [internal]
1656  */
1657 static  DWORD   CALLBACK        widRecorder(LPVOID pmt)
1658 {
1659     WORD                uDevID = (DWORD)pmt;
1660     WINE_WAVEIN*        wwi = (WINE_WAVEIN*)&WInDev[uDevID];
1661     WAVEHDR*            lpWaveHdr;
1662     DWORD               dwSleepTime;
1663     DWORD               bytesRead;
1664     int                 dwBufferSpace;
1665     enum win_wm_message msg;
1666     DWORD               param;
1667     HANDLE              ev;
1668
1669     SetEvent(wwi->hStartUpEvent);
1670
1671     /* make sleep time to be # of ms to record one packet */
1672     dwSleepTime = ((1 << (wwi->packetSettings & 0xFFFF)) * 1000) / wwi->format.wf.nAvgBytesPerSec;
1673     TRACE("sleeptime=%ld ms\n", dwSleepTime);
1674
1675     for(;;) {
1676         /* Oddly enough, dwBufferSpace is sometimes negative....
1677          *
1678          * NOTE: If you remove this call to arts_stream_get() and
1679          * remove the && (dwBufferSpace > 0) the code will still
1680          * function correctly. I don't know which way is
1681          * faster/better.
1682          */
1683         dwBufferSpace = arts_stream_get(wwi->record_stream, ARTS_P_BUFFER_SPACE);
1684         TRACE("wwi->lpQueuePtr=(%p), wwi->state=(%d), dwBufferSpace=(%d)\n",wwi->lpQueuePtr,wwi->state,dwBufferSpace);
1685
1686         /* read all data is arts input buffer. */
1687         if ((wwi->lpQueuePtr != NULL) && (wwi->state == WINE_WS_PLAYING) && (dwBufferSpace > 0))
1688         {
1689             lpWaveHdr = wwi->lpQueuePtr;
1690
1691             TRACE("read as much as we can\n");
1692             while(wwi->lpQueuePtr)
1693             {
1694                 TRACE("attempt to read %ld bytes\n",lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded);
1695                 bytesRead = arts_read(wwi->record_stream,
1696                                       lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded,
1697                                       lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded);
1698                 TRACE("bytesRead=%ld\n",bytesRead);
1699                 if (bytesRead==0) break;
1700
1701                 lpWaveHdr->dwBytesRecorded      += bytesRead;
1702                 wwi->dwRecordedTotal            += bytesRead;
1703
1704                 /* buffer full. notify client */
1705                 if (lpWaveHdr->dwBytesRecorded >= lpWaveHdr->dwBufferLength)
1706                 {
1707                     /* must copy the value of next waveHdr, because we have no idea of what
1708                      * will be done with the content of lpWaveHdr in callback
1709                      */
1710                     LPWAVEHDR   lpNext = lpWaveHdr->lpNext;
1711
1712                     TRACE("waveHdr full.\n");
1713
1714                     lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1715                     lpWaveHdr->dwFlags |=  WHDR_DONE;
1716
1717                     widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
1718                     lpWaveHdr = wwi->lpQueuePtr = lpNext;
1719                 }
1720             }
1721         }
1722
1723         /* wait for dwSleepTime or an event in thread's queue */
1724         WaitForSingleObject(wwi->msgRing.msg_event, dwSleepTime);
1725
1726         while (ARTS_RetrieveRingMessage(&wwi->msgRing, &msg, &param, &ev))
1727         {
1728             TRACE("msg=%s param=0x%lx\n",wodPlayerCmdString[msg - WM_USER - 1], param);
1729             switch(msg) {
1730             case WINE_WM_PAUSING:
1731                 wwi->state = WINE_WS_PAUSED;
1732
1733                 /* Put code here to "pause" arts recording
1734                  */
1735
1736                 SetEvent(ev);
1737                 break;
1738             case WINE_WM_STARTING:
1739                 wwi->state = WINE_WS_PLAYING;
1740
1741                 /* Put code here to "start" arts recording
1742                  */
1743
1744                 SetEvent(ev);
1745                 break;
1746             case WINE_WM_HEADER:
1747                 lpWaveHdr = (LPWAVEHDR)param;
1748                 /* insert buffer at end of queue */
1749                 {
1750                     LPWAVEHDR* wh;
1751                     int num_headers = 0;
1752                     for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext))
1753                     {
1754                         num_headers++;
1755
1756                     }
1757                     *wh=lpWaveHdr;
1758                 }
1759                 break;
1760             case WINE_WM_STOPPING:
1761                 if (wwi->state != WINE_WS_STOPPED)
1762                 {
1763
1764                     /* Put code here to "stop" arts recording
1765                      */
1766
1767                     /* return current buffer to app */
1768                     lpWaveHdr = wwi->lpQueuePtr;
1769                     if (lpWaveHdr)
1770                     {
1771                         LPWAVEHDR lpNext = lpWaveHdr->lpNext;
1772                         TRACE("stop %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
1773                         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1774                         lpWaveHdr->dwFlags |= WHDR_DONE;
1775                         widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
1776                         wwi->lpQueuePtr = lpNext;
1777                     }
1778                 }
1779                 wwi->state = WINE_WS_STOPPED;
1780                 SetEvent(ev);
1781                 break;
1782             case WINE_WM_RESETTING:
1783                 wwi->state = WINE_WS_STOPPED;
1784                 wwi->dwRecordedTotal = 0;
1785
1786                 /* return all buffers to the app */
1787                 for (lpWaveHdr = wwi->lpQueuePtr; lpWaveHdr; lpWaveHdr = lpWaveHdr->lpNext) {
1788                     TRACE("reset %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
1789                     lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1790                     lpWaveHdr->dwFlags |= WHDR_DONE;
1791
1792                     widNotifyClient(wwi, WIM_DATA, (DWORD)lpWaveHdr, 0);
1793                 }
1794                 wwi->lpQueuePtr = NULL;
1795                 SetEvent(ev);
1796                 break;
1797             case WINE_WM_CLOSING:
1798                 wwi->hThread = 0;
1799                 wwi->state = WINE_WS_CLOSED;
1800                 SetEvent(ev);
1801                 ExitThread(0);
1802                 /* shouldn't go here */
1803             default:
1804                 FIXME("unknown message %d\n", msg);
1805                 break;
1806             }
1807         }
1808     }
1809     ExitThread(0);
1810     /* just for not generating compilation warnings... should never be executed */
1811     return 0;
1812 }
1813
1814 /**************************************************************************
1815  *                              widOpen                         [internal]
1816  */
1817 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1818 {
1819     WINE_WAVEIN*        wwi;
1820
1821     TRACE("(%u, %p %08lX);\n",wDevID, lpDesc, dwFlags);
1822     if (lpDesc == NULL) {
1823         WARN("Invalid Parametr (lpDesc == NULL)!\n");
1824         return MMSYSERR_INVALPARAM;
1825     }
1826
1827     if (wDevID >= MAX_WAVEINDRV) {
1828         TRACE ("MAX_WAVEINDRV reached !\n");
1829         return MMSYSERR_BADDEVICEID;
1830     }
1831
1832     /* if this device is already open tell the app that it is allocated */
1833     if(WInDev[wDevID].record_stream != (arts_stream_t*)-1)
1834     {
1835         TRACE("device already allocated\n");
1836         return MMSYSERR_ALLOCATED;
1837     }
1838
1839     /* only PCM format is support so far... */
1840     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1841         lpDesc->lpFormat->nChannels == 0 ||
1842         lpDesc->lpFormat->nSamplesPerSec < DSBFREQUENCY_MIN ||
1843         lpDesc->lpFormat->nSamplesPerSec > DSBFREQUENCY_MAX ||
1844         (lpDesc->lpFormat->wBitsPerSample!=8 && lpDesc->lpFormat->wBitsPerSample!=16)) {
1845         WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1846              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1847              lpDesc->lpFormat->nSamplesPerSec);
1848         return WAVERR_BADFORMAT;
1849     }
1850
1851     if (dwFlags & WAVE_FORMAT_QUERY) {
1852         TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1853              lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1854              lpDesc->lpFormat->nSamplesPerSec);
1855         return MMSYSERR_NOERROR;
1856     }
1857
1858     wwi = &WInDev[wDevID];
1859
1860     /* direct sound not supported, ignore the flag */
1861     dwFlags &= ~WAVE_DIRECTSOUND;
1862
1863     wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1864
1865     memcpy(&wwi->waveDesc, lpDesc,           sizeof(WAVEOPENDESC));
1866     memcpy(&wwi->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
1867
1868     if (wwi->format.wBitsPerSample == 0) {
1869         WARN("Resetting zerod wBitsPerSample\n");
1870         wwi->format.wBitsPerSample = 8 *
1871             (wwi->format.wf.nAvgBytesPerSec /
1872              wwi->format.wf.nSamplesPerSec) /
1873             wwi->format.wf.nChannels;
1874     }
1875
1876     wwi->record_stream = arts_record_stream(wwi->format.wf.nSamplesPerSec,
1877                                             wwi->format.wBitsPerSample,
1878                                             wwi->format.wf.nChannels,
1879                                             "winearts");
1880     TRACE("(wwi->record_stream=%p)\n",wwi->record_stream);
1881     wwi->state = WINE_WS_STOPPED;
1882
1883     wwi->packetSettings = arts_stream_set(wwi->record_stream, ARTS_P_PACKET_SETTINGS, WAVEIN_PACKET_SETTINGS);
1884     TRACE("Tried to set ARTS_P_PACKET_SETTINGS to (%x), actually set to (%x)\n", WAVEIN_PACKET_SETTINGS, wwi->packetSettings);
1885     TRACE("Buffer size is now (%d)\n", arts_stream_get(wwi->record_stream, ARTS_P_BUFFER_SIZE));
1886
1887     if (wwi->lpQueuePtr) {
1888         WARN("Should have an empty queue (%p)\n", wwi->lpQueuePtr);
1889         wwi->lpQueuePtr = NULL;
1890     }
1891     arts_stream_set(wwi->record_stream, ARTS_P_BLOCKING, 0);    /* disable blocking on this stream */
1892
1893     if(!wwi->record_stream) return MMSYSERR_ALLOCATED;
1894
1895     wwi->dwRecordedTotal = 0;
1896     wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1897
1898     ARTS_InitRingMessage(&wwi->msgRing);
1899
1900     /* create recorder thread */
1901     if (!(dwFlags & WAVE_DIRECTSOUND)) {
1902         wwi->hStartUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1903         wwi->hThread = CreateThread(NULL, 0, widRecorder, (LPVOID)(DWORD)wDevID, 0, &(wwi->dwThreadID));
1904         WaitForSingleObject(wwi->hStartUpEvent, INFINITE);
1905         CloseHandle(wwi->hStartUpEvent);
1906     } else {
1907         wwi->hThread = INVALID_HANDLE_VALUE;
1908         wwi->dwThreadID = 0;
1909     }
1910     wwi->hStartUpEvent = INVALID_HANDLE_VALUE;
1911
1912     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n",
1913           wwi->format.wBitsPerSample, wwi->format.wf.nAvgBytesPerSec,
1914           wwi->format.wf.nSamplesPerSec, wwi->format.wf.nChannels,
1915           wwi->format.wf.nBlockAlign);
1916     return widNotifyClient(wwi, WIM_OPEN, 0L, 0L);
1917 }
1918
1919 /**************************************************************************
1920  *                              widClose                        [internal]
1921  */
1922 static DWORD widClose(WORD wDevID)
1923 {
1924     WINE_WAVEIN*        wwi;
1925
1926     TRACE("(%u);\n", wDevID);
1927     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
1928         WARN("can't close !\n");
1929         return MMSYSERR_INVALHANDLE;
1930     }
1931
1932     wwi = &WInDev[wDevID];
1933
1934     if (wwi->lpQueuePtr != NULL) {
1935         WARN("still buffers open !\n");
1936         return WAVERR_STILLPLAYING;
1937     }
1938
1939     ARTS_AddRingMessage(&wwi->msgRing, WINE_WM_CLOSING, 0, TRUE);
1940     ARTS_CloseWaveInDevice(wwi);
1941     wwi->state = WINE_WS_CLOSED;
1942     ARTS_DestroyRingMessage(&wwi->msgRing);
1943     return widNotifyClient(wwi, WIM_CLOSE, 0L, 0L);
1944 }
1945
1946 /**************************************************************************
1947  *                              widAddBuffer            [internal]
1948  */
1949 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1950 {
1951     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1952
1953     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
1954         WARN("can't do it !\n");
1955         return MMSYSERR_INVALHANDLE;
1956     }
1957     if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) {
1958         TRACE("never been prepared !\n");
1959         return WAVERR_UNPREPARED;
1960     }
1961     if (lpWaveHdr->dwFlags & WHDR_INQUEUE) {
1962         TRACE("header already in use !\n");
1963         return WAVERR_STILLPLAYING;
1964     }
1965
1966     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1967     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1968     lpWaveHdr->dwBytesRecorded = 0;
1969     lpWaveHdr->lpNext = NULL;
1970
1971     ARTS_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
1972     return MMSYSERR_NOERROR;
1973 }
1974
1975 /**************************************************************************
1976  *                              widPrepare                      [internal]
1977  */
1978 static DWORD widPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1979 {
1980     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1981
1982     if (wDevID >= MAX_WAVEINDRV) return MMSYSERR_INVALHANDLE;
1983
1984     if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1985         return WAVERR_STILLPLAYING;
1986
1987     lpWaveHdr->dwFlags |= WHDR_PREPARED;
1988     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1989     lpWaveHdr->dwBytesRecorded = 0;
1990
1991     return MMSYSERR_NOERROR;
1992 }
1993
1994 /**************************************************************************
1995  *                              widUnprepare                    [internal]
1996  */
1997 static DWORD widUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1998 {
1999     TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
2000     if (wDevID >= MAX_WAVEINDRV) {
2001         WARN("bad device ID !\n");
2002         return MMSYSERR_INVALHANDLE;
2003     }
2004
2005     if (lpWaveHdr->dwFlags & WHDR_INQUEUE) {
2006         TRACE("Still playing...\n");
2007         return WAVERR_STILLPLAYING;
2008     }
2009
2010     lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
2011     lpWaveHdr->dwFlags |= WHDR_DONE;
2012
2013     return MMSYSERR_NOERROR;
2014 }
2015
2016 /**************************************************************************
2017  *                      widStart                                [internal]
2018  */
2019 static DWORD widStart(WORD wDevID)
2020 {
2021     TRACE("(%u);\n", wDevID);
2022     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2023         WARN("can't start recording !\n");
2024         return MMSYSERR_INVALHANDLE;
2025     }
2026
2027     ARTS_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_STARTING, 0, TRUE);
2028     return MMSYSERR_NOERROR;
2029 }
2030
2031 /**************************************************************************
2032  *                      widStop                                 [internal]
2033  */
2034 static DWORD widStop(WORD wDevID)
2035 {
2036     TRACE("(%u);\n", wDevID);
2037     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2038         WARN("can't stop !\n");
2039         return MMSYSERR_INVALHANDLE;
2040     }
2041
2042     ARTS_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_STOPPING, 0, TRUE);
2043
2044     return MMSYSERR_NOERROR;
2045 }
2046
2047 /**************************************************************************
2048  *                      widReset                                [internal]
2049  */
2050 static DWORD widReset(WORD wDevID)
2051 {
2052     TRACE("(%u);\n", wDevID);
2053     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2054         WARN("can't reset !\n");
2055         return MMSYSERR_INVALHANDLE;
2056     }
2057     ARTS_AddRingMessage(&WInDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
2058     return MMSYSERR_NOERROR;
2059 }
2060
2061 /**************************************************************************
2062  *                              widMessage (WINEARTS.6)
2063  */
2064 DWORD WINAPI ARTS_widMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
2065                             DWORD dwParam1, DWORD dwParam2)
2066 {
2067     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
2068           wDevID, wMsg, dwUser, dwParam1, dwParam2);
2069     switch (wMsg) {
2070     case DRVM_INIT:
2071     case DRVM_EXIT:
2072     case DRVM_ENABLE:
2073     case DRVM_DISABLE:
2074         /* FIXME: Pretend this is supported */
2075         return 0;
2076     case WIDM_OPEN:             return widOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,      dwParam2);
2077     case WIDM_CLOSE:            return widClose         (wDevID);
2078     case WIDM_ADDBUFFER:        return widAddBuffer     (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2079     case WIDM_PREPARE:          return widPrepare       (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2080     case WIDM_UNPREPARE:        return widUnprepare     (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2081     case WIDM_GETDEVCAPS:       return widGetDevCaps    (wDevID, (LPWAVEINCAPSW)dwParam1,       dwParam2);
2082     case WIDM_GETNUMDEVS:       return widGetNumDevs    ();
2083     case WIDM_RESET:            return widReset         (wDevID);
2084     case WIDM_START:            return widStart         (wDevID);
2085     case WIDM_STOP:             return widStop          (wDevID);
2086     case DRV_QUERYDEVICEINTERFACESIZE: return widDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
2087     case DRV_QUERYDEVICEINTERFACE:     return widDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
2088     default:
2089         FIXME("unknown message %d!\n", wMsg);
2090     }
2091     return MMSYSERR_NOTSUPPORTED;
2092 }
2093
2094 /*======================================================================*
2095  *                  Low level DSOUND implementation                     *
2096  *======================================================================*/
2097 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
2098 {
2099     /* we can't perform memory mapping as we don't have a file stream
2100         interface with arts like we do with oss */
2101     MESSAGE("This sound card's driver does not support direct access\n");
2102     MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
2103     return MMSYSERR_NOTSUPPORTED;
2104 }
2105
2106 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
2107 {
2108     memset(desc, 0, sizeof(*desc));
2109     strcpy(desc->szDesc, "Wine aRts DirectSound Driver");
2110     strcpy(desc->szDrvname, "winearts.drv");
2111     return MMSYSERR_NOERROR;
2112 }
2113
2114 #else /* !HAVE_ARTS */
2115
2116 /**************************************************************************
2117  *                              wodMessage (WINEARTS.@)
2118  */
2119 DWORD WINAPI ARTS_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2120                             DWORD dwParam1, DWORD dwParam2)
2121 {
2122     FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2123     return MMSYSERR_NOTENABLED;
2124 }
2125
2126 /**************************************************************************
2127  *                              widMessage (WINEARTS.6)
2128  */
2129 DWORD WINAPI ARTS_widMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
2130                             DWORD dwParam1, DWORD dwParam2)
2131 {
2132     FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2133     return MMSYSERR_NOTENABLED;
2134 }
2135
2136 #endif /* HAVE_ARTS */