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