?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed warnings with gcc option "-Wwrite-strings".
[wine/multimedia.git] / dlls / winmm / winealsa / audio.c
bloba016a8e19a39dff32c63a3e6b71ea17a225dc6ae
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 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34 #include <errno.h>
35 #include <limits.h>
36 #include <fcntl.h>
37 #ifdef HAVE_SYS_IOCTL_H
38 # include <sys/ioctl.h>
39 #endif
40 #ifdef HAVE_SYS_MMAN_H
41 # include <sys/mman.h>
42 #endif
43 #include "windef.h"
44 #include "winbase.h"
45 #include "wingdi.h"
46 #include "winerror.h"
47 #include "winuser.h"
48 #include "mmddk.h"
49 #include "dsound.h"
50 #include "dsdriver.h"
51 #include "alsa.h"
52 #include "wine/library.h"
53 #include "wine/debug.h"
54
55 WINE_DEFAULT_DEBUG_CHANNEL(wave);
56
57
58 #if defined(HAVE_ALSA) && ((SND_LIB_MAJOR == 0 && SND_LIB_MINOR >= 9) || SND_LIB_MAJOR >= 1)
59
60 /* internal ALSALIB functions */
61 snd_pcm_uframes_t _snd_pcm_mmap_hw_ptr(snd_pcm_t *pcm);
62
63
64 #define MAX_WAVEOUTDRV (1)
65 #define MAX_WAVEINDRV (1)
66
67 /* state diagram for waveOut writing:
68 *
69 * +---------+-------------+---------------+---------------------------------+
70 * | state | function | event | new state |
71 * +---------+-------------+---------------+---------------------------------+
72 * | | open() | | STOPPED |
73 * | PAUSED | write() | | PAUSED |
74 * | STOPPED | write() | <thrd create> | PLAYING |
75 * | PLAYING | write() | HEADER | PLAYING |
76 * | (other) | write() | <error> | |
77 * | (any) | pause() | PAUSING | PAUSED |
78 * | PAUSED | restart() | RESTARTING | PLAYING (if no thrd => STOPPED) |
79 * | (any) | reset() | RESETTING | STOPPED |
80 * | (any) | close() | CLOSING | CLOSED |
81 * +---------+-------------+---------------+---------------------------------+
82 */
83
84 /* states of the playing device */
85 #define WINE_WS_PLAYING 0
86 #define WINE_WS_PAUSED 1
87 #define WINE_WS_STOPPED 2
88 #define WINE_WS_CLOSED 3
89
90 /* events to be send to device */
91 enum win_wm_message {
92 WINE_WM_PAUSING = WM_USER + 1, WINE_WM_RESTARTING, WINE_WM_RESETTING, WINE_WM_HEADER,
93 WINE_WM_UPDATE, WINE_WM_BREAKLOOP, WINE_WM_CLOSING
94 };
95
96 typedef struct {
97 enum win_wm_message msg; /* message identifier */
98 DWORD param; /* parameter for this message */
99 HANDLE hEvent; /* if message is synchronous, handle of event for synchro */
100 } ALSA_MSG;
101
102 /* implement an in-process message ring for better performance
103 * (compared to passing thru the server)
104 * this ring will be used by the input (resp output) record (resp playback) routine
105 */
106 #define ALSA_RING_BUFFER_INCREMENT 64
107 typedef struct {
108 ALSA_MSG * messages;
109 int ring_buffer_size;
110 int msg_tosave;
111 int msg_toget;
112 HANDLE msg_event;
113 CRITICAL_SECTION msg_crst;
114 } ALSA_MSG_RING;
115
116 typedef struct {
117 /* Windows information */
118 volatile int state; /* one of the WINE_WS_ manifest constants */
119 WAVEOPENDESC waveDesc;
120 WORD wFlags;
121 PCMWAVEFORMAT format;
122 WAVEOUTCAPSA caps;
123
124 /* ALSA information (ALSA 0.9/1.x uses two different devices for playback/capture) */
125 char * device;
126 snd_pcm_t* p_handle; /* handle to ALSA playback device */
127 snd_pcm_t* c_handle; /* handle to ALSA capture device */
128 snd_pcm_hw_params_t * hw_params; /* ALSA Hw params */
129
130 snd_ctl_t * ctl; /* control handle for the playback volume */
131 snd_ctl_elem_id_t * playback_eid; /* element id of the playback volume control */
132 snd_ctl_elem_value_t * playback_evalue; /* element value of the playback volume control */
133 snd_ctl_elem_info_t * playback_einfo; /* element info of the playback volume control */
134
135 snd_pcm_sframes_t (*write)(snd_pcm_t *, const void *, snd_pcm_uframes_t );
136
137 struct pollfd *ufds;
138 int count;
139
140 DWORD dwBufferSize; /* size of whole ALSA buffer in bytes */
141 LPWAVEHDR lpQueuePtr; /* start of queued WAVEHDRs (waiting to be notified) */
142 LPWAVEHDR lpPlayPtr; /* start of not yet fully played buffers */
143
144 LPWAVEHDR lpLoopPtr; /* pointer of first buffer in loop, if any */
145 DWORD dwLoops; /* private copy of loop counter */
146
147 DWORD dwPlayedTotal;
148
149 /* synchronization stuff */
150 HANDLE hStartUpEvent;
151 HANDLE hThread;
152 DWORD dwThreadID;
153 ALSA_MSG_RING msgRing;
154
155 /* DirectSound stuff */
156 DSDRIVERDESC ds_desc;
157 GUID ds_guid;
158 } WINE_WAVEOUT;
159
160 static WINE_WAVEOUT WOutDev [MAX_WAVEOUTDRV];
161 static DWORD ALSA_WodNumDevs;
162
163 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv);
164 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc);
165 static DWORD wodDsGuid(UINT wDevID, LPGUID pGuid);
166
167 /* These strings used only for tracing */
168 #if 0
169 static const char *wodPlayerCmdString[] = {
170 "WINE_WM_PAUSING",
171 "WINE_WM_RESTARTING",
172 "WINE_WM_RESETTING",
173 "WINE_WM_HEADER",
174 "WINE_WM_UPDATE",
175 "WINE_WM_BREAKLOOP",
176 "WINE_WM_CLOSING",
177 };
178 #endif
179
180 /*======================================================================*
181 * Low level WAVE implementation *
182 *======================================================================*/
183
184 /**************************************************************************
185 * ALSA_InitializeVolumeCtl [internal]
186 *
187 * used to initialize the PCM Volume Control
188 */
189 static int ALSA_InitializeVolumeCtl(WINE_WAVEOUT * wwo)
190 {
191 snd_ctl_t * ctl = NULL;
192 snd_ctl_card_info_t * cardinfo;
193 snd_ctl_elem_list_t * elemlist;
194 snd_ctl_elem_id_t * e_id;
195 snd_ctl_elem_info_t * einfo;
196 snd_hctl_t * hctl = NULL;
197 snd_hctl_elem_t * elem;
198 int nCtrls;
199 int i;
200
201 snd_ctl_card_info_alloca(&cardinfo);
202 memset(cardinfo,0,snd_ctl_card_info_sizeof());
203
204 snd_ctl_elem_list_alloca(&elemlist);
205 memset(elemlist,0,snd_ctl_elem_list_sizeof());
206
207 snd_ctl_elem_id_alloca(&e_id);
208 memset(e_id,0,snd_ctl_elem_id_sizeof());
209
210 snd_ctl_elem_info_alloca(&einfo);
211 memset(einfo,0,snd_ctl_elem_info_sizeof());
212
213 #define EXIT_ON_ERROR(f,txt) do \
214 { \
215 int err; \
216 if ( (err = (f) ) < 0) \
217 { \
218 ERR(txt ": %s\n", snd_strerror(err)); \
219 if (hctl) \
220 snd_hctl_close(hctl); \
221 if (ctl) \
222 snd_ctl_close(ctl); \
223 return -1; \
224 } \
225 } while(0)
226
227 EXIT_ON_ERROR( snd_ctl_open(&ctl,"hw",0) , "ctl open failed" );
228 EXIT_ON_ERROR( snd_ctl_card_info(ctl, cardinfo), "card info failed");
229 EXIT_ON_ERROR( snd_ctl_elem_list(ctl, elemlist), "elem list failed");
230
231 nCtrls = snd_ctl_elem_list_get_count(elemlist);
232
233 EXIT_ON_ERROR( snd_hctl_open(&hctl,"hw",0), "hctl open failed");
234 EXIT_ON_ERROR( snd_hctl_load(hctl), "hctl load failed" );
235
236 elem=snd_hctl_first_elem(hctl);
237 for ( i= 0; i<nCtrls; i++) {
238
239 memset(e_id,0,snd_ctl_elem_id_sizeof());
240
241 snd_hctl_elem_get_id(elem,e_id);
242 /*
243 TRACE("ctl: #%d '%s'%d\n",
244 snd_ctl_elem_id_get_numid(e_id),
245 snd_ctl_elem_id_get_name(e_id),
246 snd_ctl_elem_id_get_index(e_id));
247 */
248 if ( !strcmp("PCM Playback Volume", snd_ctl_elem_id_get_name(e_id)) )
249 {
250 EXIT_ON_ERROR( snd_hctl_elem_info(elem,einfo), "hctl elem info failed" );
251
252 /* few sanity checks... you'll never know... */
253 if ( snd_ctl_elem_info_get_type(einfo) != SND_CTL_ELEM_TYPE_INTEGER )
254 WARN("playback volume control is not an integer\n");
255 if ( !snd_ctl_elem_info_is_readable(einfo) )
256 WARN("playback volume control is readable\n");
257 if ( !snd_ctl_elem_info_is_writable(einfo) )
258 WARN("playback volume control is readable\n");
259
260 TRACE(" ctrl range: min=%ld max=%ld step=%ld\n",
261 snd_ctl_elem_info_get_min(einfo),
262 snd_ctl_elem_info_get_max(einfo),
263 snd_ctl_elem_info_get_step(einfo));
264
265 EXIT_ON_ERROR( snd_ctl_elem_id_malloc(&wwo->playback_eid), "elem id malloc failed" );
266 EXIT_ON_ERROR( snd_ctl_elem_info_malloc(&wwo->playback_einfo), "elem info malloc failed" );
267 EXIT_ON_ERROR( snd_ctl_elem_value_malloc(&wwo->playback_evalue), "elem value malloc failed" );
268
269 /* ok, now we can safely save these objects for later */
270 snd_ctl_elem_id_copy(wwo->playback_eid, e_id);
271 snd_ctl_elem_info_copy(wwo->playback_einfo, einfo);
272 snd_ctl_elem_value_set_id(wwo->playback_evalue, wwo->playback_eid);
273 wwo->ctl = ctl;
274 }
275
276 elem=snd_hctl_elem_next(elem);
277 }
278 snd_hctl_close(hctl);
279 #undef EXIT_ON_ERROR
280 return 0;
281 }
282
283 /**************************************************************************
284 * ALSA_XRUNRecovery [internal]
285 *
286 * used to recovery from XRUN errors (buffer underflow/overflow)
287 */
288 static int ALSA_XRUNRecovery(WINE_WAVEOUT * wwo, int err)
289 {
290 if (err == -EPIPE) { /* under-run */
291 err = snd_pcm_prepare(wwo->p_handle);
292 if (err < 0)
293 ERR( "underrun recovery failed. prepare failed: %s\n", snd_strerror(err));
294 return 0;
295 } else if (err == -ESTRPIPE) {
296 while ((err = snd_pcm_resume(wwo->p_handle)) == -EAGAIN)
297 sleep(1); /* wait until the suspend flag is released */
298 if (err < 0) {
299 err = snd_pcm_prepare(wwo->p_handle);
300 if (err < 0)
301 ERR("recovery from suspend failed, prepare failed: %s\n", snd_strerror(err));
302 }
303 return 0;
304 }
305 return err;
306 }
307
308 /**************************************************************************
309 * ALSA_TraceParameters [internal]
310 *
311 * used to trace format changes, hw and sw parameters
312 */
313 static void ALSA_TraceParameters(snd_pcm_hw_params_t * hw_params, snd_pcm_sw_params_t * sw, int full)
314 {
315 snd_pcm_format_t format = snd_pcm_hw_params_get_format(hw_params);
316 snd_pcm_access_t access = snd_pcm_hw_params_get_access(hw_params);
317
318 #define X(x) ((x)? "true" : "false")
319 if (full)
320 TRACE("FLAGS: sampleres=%s overrng=%s pause=%s resume=%s syncstart=%s batch=%s block=%s double=%s "
321 "halfd=%s joint=%s \n",
322 X(snd_pcm_hw_params_can_mmap_sample_resolution(hw_params)),
323 X(snd_pcm_hw_params_can_overrange(hw_params)),
324 X(snd_pcm_hw_params_can_pause(hw_params)),
325 X(snd_pcm_hw_params_can_resume(hw_params)),
326 X(snd_pcm_hw_params_can_sync_start(hw_params)),
327 X(snd_pcm_hw_params_is_batch(hw_params)),
328 X(snd_pcm_hw_params_is_block_transfer(hw_params)),
329 X(snd_pcm_hw_params_is_double(hw_params)),
330 X(snd_pcm_hw_params_is_half_duplex(hw_params)),
331 X(snd_pcm_hw_params_is_joint_duplex(hw_params)));
332 #undef X
333
334 if (access >= 0)
335 TRACE("access=%s\n", snd_pcm_access_name(access));
336 else
337 {
338 snd_pcm_access_mask_t * acmask;
339 snd_pcm_access_mask_alloca(&acmask);
340 snd_pcm_hw_params_get_access_mask(hw_params, acmask);
341 for ( access = SND_PCM_ACCESS_MMAP_INTERLEAVED; access <= SND_PCM_ACCESS_LAST; access++)
342 if (snd_pcm_access_mask_test(acmask, access))
343 TRACE("access=%s\n", snd_pcm_access_name(access));
344 }
345
346 if (format >= 0)
347 {
348 TRACE("format=%s\n", snd_pcm_format_name(format));
349
350 }
351 else
352 {
353 snd_pcm_format_mask_t * fmask;
354
355 snd_pcm_format_mask_alloca(&fmask);
356 snd_pcm_hw_params_get_format_mask(hw_params, fmask);
357 for ( format = SND_PCM_FORMAT_S8; format <= SND_PCM_FORMAT_LAST ; format++)
358 if ( snd_pcm_format_mask_test(fmask, format) )
359 TRACE("format=%s\n", snd_pcm_format_name(format));
360 }
361
362 #define X(x) do { \
363 int n = snd_pcm_hw_params_get_##x(hw_params); \
364 if (n<0) \
365 TRACE(#x "_min=%ld " #x "_max=%ld\n", \
366 (long int)snd_pcm_hw_params_get_##x##_min(hw_params), \
367 (long int)snd_pcm_hw_params_get_##x##_max(hw_params)); \
368 else \
369 TRACE(#x "=%d\n", n); \
370 } while(0)
371 X(channels);
372 X(buffer_size);
373 #undef X
374
375 #define X(x) do { \
376 int n = snd_pcm_hw_params_get_##x(hw_params,0); \
377 if (n<0) \
378 TRACE(#x "_min=%ld " #x "_max=%ld\n", \
379 (long int)snd_pcm_hw_params_get_##x##_min(hw_params,0), \
380 (long int)snd_pcm_hw_params_get_##x##_max(hw_params,0)); \
381 else \
382 TRACE(#x "=%d\n", n); \
383 } while(0)
384 X(rate);
385 X(buffer_time);
386 X(periods);
387 X(period_size);
388 X(period_time);
389 X(tick_time);
390 #undef X
391
392 if (!sw)
393 return;
394
395
396 }
397
398
399
400 /******************************************************************
401 * ALSA_WaveInit
402 *
403 * Initialize internal structures from ALSA information
404 */
405 LONG ALSA_WaveInit(void)
406 {
407 snd_pcm_t* h = NULL;
408 snd_pcm_info_t * info;
409 snd_pcm_hw_params_t * hw_params;
410 WINE_WAVEOUT* wwo;
411 char device[] = "hw";
412
413 wwo = &WOutDev[0];
414
415 /* FIXME: use better values */
416 wwo->device = device;
417 wwo->caps.wMid = 0x0002;
418 wwo->caps.wPid = 0x0104;
419 strcpy(wwo->caps.szPname, "SB16 Wave Out");
420 wwo->caps.vDriverVersion = 0x0100;
421 wwo->caps.dwFormats = 0x00000000;
422 wwo->caps.dwSupport = WAVECAPS_VOLUME;
423 strcpy(wwo->ds_desc.szDesc, "WineALSA DirectSound Driver");
424 strcpy(wwo->ds_desc.szDrvName, "winealsa.drv");
425 wwo->ds_guid = DSDEVID_DefaultPlayback;
426
427 if (!wine_dlopen("libasound.so.2", RTLD_LAZY|RTLD_GLOBAL, NULL, 0))
428 {
429 ERR("Error: ALSA lib needs to be loaded with flags RTLD_LAZY and RTLD_GLOBAL.\n");
430 return -1;
431 }
432
433 snd_pcm_info_alloca(&info);
434 snd_pcm_hw_params_alloca(&hw_params);
435
436 #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)
437
438 ALSA_WodNumDevs = 0;
439 EXIT_ON_ERROR( snd_pcm_open(&h, wwo->device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) , "open pcm" );
440 if (!h) return -1;
441 ALSA_WodNumDevs++;
442
443 EXIT_ON_ERROR( snd_pcm_info(h, info) , "pcm info" );
444
445 TRACE("dev=%d id=%s name=%s subdev=%d subdev_name=%s subdev_avail=%d subdev_num=%d stream=%s subclass=%s \n",
446 snd_pcm_info_get_device(info),
447 snd_pcm_info_get_id(info),
448 snd_pcm_info_get_name(info),
449 snd_pcm_info_get_subdevice(info),
450 snd_pcm_info_get_subdevice_name(info),
451 snd_pcm_info_get_subdevices_avail(info),
452 snd_pcm_info_get_subdevices_count(info),
453 snd_pcm_stream_name(snd_pcm_info_get_stream(info)),
454 (snd_pcm_info_get_subclass(info) == SND_PCM_SUBCLASS_GENERIC_MIX ? "GENERIC MIX": "MULTI MIX"));
455
456 EXIT_ON_ERROR( snd_pcm_hw_params_any(h, hw_params) , "pcm hw params" );
457 #undef EXIT_ON_ERROR
458
459 if (TRACE_ON(wave))
460 ALSA_TraceParameters(hw_params, NULL, TRUE);
461
462 {
463 snd_pcm_format_mask_t * fmask;
464 int ratemin = snd_pcm_hw_params_get_rate_min(hw_params, 0);
465 int ratemax = snd_pcm_hw_params_get_rate_max(hw_params, 0);
466 int chmin = snd_pcm_hw_params_get_channels_min(hw_params); \
467 int chmax = snd_pcm_hw_params_get_channels_max(hw_params); \
468
469 snd_pcm_format_mask_alloca(&fmask);
470 snd_pcm_hw_params_get_format_mask(hw_params, fmask);
471
472 #define X(r,v) \
473 if ( (r) >= ratemin && ( (r) <= ratemax || ratemax == -1) ) \
474 { \
475 if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_U8)) \
476 { \
477 if (chmin <= 1 && 1 <= chmax) \
478 wwo->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
479 if (chmin <= 2 && 2 <= chmax) \
480 wwo->caps.dwFormats |= WAVE_FORMAT_##v##S08; \
481 } \
482 if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_S16_LE)) \
483 { \
484 if (chmin <= 1 && 1 <= chmax) \
485 wwo->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
486 if (chmin <= 2 && 2 <= chmax) \
487 wwo->caps.dwFormats |= WAVE_FORMAT_##v##S16; \
488 } \
489 }
490 X(11025,1);
491 X(22050,2);
492 X(44100,4);
493 #undef X
494 }
495
496 if ( snd_pcm_hw_params_get_channels_min(hw_params) > 1) FIXME("-\n");
497 wwo->caps.wChannels = (snd_pcm_hw_params_get_channels_max(hw_params) >= 2) ? 2 : 1;
498 if (snd_pcm_hw_params_get_channels_min(hw_params) <= 2 && 2 <= snd_pcm_hw_params_get_channels_max(hw_params))
499 wwo->caps.dwSupport |= WAVECAPS_LRVOLUME;
500
501 /* FIXME: always true ? */
502 wwo->caps.dwSupport |= WAVECAPS_SAMPLEACCURATE;
503
504 {
505 snd_pcm_access_mask_t * acmask;
506 snd_pcm_access_mask_alloca(&acmask);
507 snd_pcm_hw_params_get_access_mask(hw_params, acmask);
508
509 /* FIXME: NONITERLEAVED and COMPLEX are not supported right now */
510 if ( snd_pcm_access_mask_test( acmask, SND_PCM_ACCESS_MMAP_INTERLEAVED ) )
511 wwo->caps.dwSupport |= WAVECAPS_DIRECTSOUND;
512 }
513
514 TRACE("Configured with dwFmts=%08lx dwSupport=%08lx\n",
515 wwo->caps.dwFormats, wwo->caps.dwSupport);
516
517 snd_pcm_close(h);
518
519 ALSA_InitializeVolumeCtl(wwo);
520
521 return 0;
522 }
523
524 /******************************************************************
525 * ALSA_InitRingMessage
526 *
527 * Initialize the ring of messages for passing between driver's caller and playback/record
528 * thread
529 */
530 static int ALSA_InitRingMessage(ALSA_MSG_RING* omr)
531 {
532 omr->msg_toget = 0;
533 omr->msg_tosave = 0;
534 omr->msg_event = CreateEventA(NULL, FALSE, FALSE, NULL);
535 omr->ring_buffer_size = ALSA_RING_BUFFER_INCREMENT;
536 omr->messages = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,omr->ring_buffer_size * sizeof(ALSA_MSG));
537
538 InitializeCriticalSection(&omr->msg_crst);
539 return 0;
540 }
541
542 /******************************************************************
543 * ALSA_DestroyRingMessage
544 *
545 */
546 static int ALSA_DestroyRingMessage(ALSA_MSG_RING* omr)
547 {
548 CloseHandle(omr->msg_event);
549 HeapFree(GetProcessHeap(),0,omr->messages);
550 DeleteCriticalSection(&omr->msg_crst);
551 return 0;
552 }
553
554 /******************************************************************
555 * ALSA_AddRingMessage
556 *
557 * Inserts a new message into the ring (should be called from DriverProc derivated routines)
558 */
559 static int ALSA_AddRingMessage(ALSA_MSG_RING* omr, enum win_wm_message msg, DWORD param, BOOL wait)
560 {
561 HANDLE hEvent = INVALID_HANDLE_VALUE;
562
563 EnterCriticalSection(&omr->msg_crst);
564 if ((omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size)))
565 {
566 omr->ring_buffer_size += ALSA_RING_BUFFER_INCREMENT;
567 TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
568 omr->messages = HeapReAlloc(GetProcessHeap(),0,omr->messages, omr->ring_buffer_size * sizeof(ALSA_MSG));
569 }
570 if (wait)
571 {
572 hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
573 if (hEvent == INVALID_HANDLE_VALUE)
574 {
575 ERR("can't create event !?\n");
576 LeaveCriticalSection(&omr->msg_crst);
577 return 0;
578 }
579 if (omr->msg_toget != omr->msg_tosave && omr->messages[omr->msg_toget].msg != WINE_WM_HEADER)
580 FIXME("two fast messages in the queue!!!!\n");
581
582 /* fast messages have to be added at the start of the queue */
583 omr->msg_toget = (omr->msg_toget + omr->ring_buffer_size - 1) % omr->ring_buffer_size;
584
585 omr->messages[omr->msg_toget].msg = msg;
586 omr->messages[omr->msg_toget].param = param;
587 omr->messages[omr->msg_toget].hEvent = hEvent;
588 }
589 else
590 {
591 omr->messages[omr->msg_tosave].msg = msg;
592 omr->messages[omr->msg_tosave].param = param;
593 omr->messages[omr->msg_tosave].hEvent = INVALID_HANDLE_VALUE;
594 omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
595 }
596 LeaveCriticalSection(&omr->msg_crst);
597 /* signal a new message */
598 SetEvent(omr->msg_event);
599 if (wait)
600 {
601 /* wait for playback/record thread to have processed the message */
602 WaitForSingleObject(hEvent, INFINITE);
603 CloseHandle(hEvent);
604 }
605 return 1;
606 }
607
608 /******************************************************************
609 * ALSA_RetrieveRingMessage
610 *
611 * Get a message from the ring. Should be called by the playback/record thread.
612 */
613 static int ALSA_RetrieveRingMessage(ALSA_MSG_RING* omr,
614 enum win_wm_message *msg, DWORD *param, HANDLE *hEvent)
615 {
616 EnterCriticalSection(&omr->msg_crst);
617
618 if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
619 {
620 LeaveCriticalSection(&omr->msg_crst);
621 return 0;
622 }
623
624 *msg = omr->messages[omr->msg_toget].msg;
625 omr->messages[omr->msg_toget].msg = 0;
626 *param = omr->messages[omr->msg_toget].param;
627 *hEvent = omr->messages[omr->msg_toget].hEvent;
628 omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
629 LeaveCriticalSection(&omr->msg_crst);
630 return 1;
631 }
632
633 /*======================================================================*
634 * Low level WAVE OUT implementation *
635 *======================================================================*/
636
637
638 /**************************************************************************
639 * wodNotifyClient [internal]
640 */
641 static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2)
642 {
643 TRACE("wMsg = 0x%04x dwParm1 = %04lX dwParam2 = %04lX\n", wMsg, dwParam1, dwParam2);
644
645 switch (wMsg) {
646 case WOM_OPEN:
647 case WOM_CLOSE:
648 case WOM_DONE:
649 if (wwo->wFlags != DCB_NULL &&
650 !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, (HDRVR)wwo->waveDesc.hWave,
651 wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
652 WARN("can't notify client !\n");
653 return MMSYSERR_ERROR;
654 }
655 break;
656 default:
657 FIXME("Unknown callback message %u\n", wMsg);
658 return MMSYSERR_INVALPARAM;
659 }
660 return MMSYSERR_NOERROR;
661 }
662
663 /**************************************************************************
664 * wodUpdatePlayedTotal [internal]
665 *
666 */
667 static BOOL wodUpdatePlayedTotal(WINE_WAVEOUT* wwo, snd_pcm_status_t* ps)
668 {
669 return TRUE;
670 }
671
672 /**************************************************************************
673 * wodPlayer_BeginWaveHdr [internal]
674 *
675 * Makes the specified lpWaveHdr the currently playing wave header.
676 * If the specified wave header is a begin loop and we're not already in
677 * a loop, setup the loop.
678 */
679 static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
680 {
681 wwo->lpPlayPtr = lpWaveHdr;
682
683 if (!lpWaveHdr) return;
684
685 wwo->lpPlayPtr->reserved = 0;
686
687 if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
688 if (wwo->lpLoopPtr) {
689 WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
690 } else {
691 TRACE("Starting loop (%ldx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
692 wwo->lpLoopPtr = lpWaveHdr;
693 /* Windows does not touch WAVEHDR.dwLoops,
694 * so we need to make an internal copy */
695 wwo->dwLoops = lpWaveHdr->dwLoops;
696 }
697 }
698 }
699
700 /**************************************************************************
701 * wodPlayer_PlayPtrNext [internal]
702 *
703 * Advance the play pointer to the next waveheader, looping if required.
704 */
705 static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEOUT* wwo)
706 {
707 LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
708
709 if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
710 /* We're at the end of a loop, loop if required */
711 if (--wwo->dwLoops > 0) {
712 wwo->lpPlayPtr = wwo->lpLoopPtr;
713 wwo->lpPlayPtr->reserved = 0;
714 } else {
715 /* Handle overlapping loops correctly */
716 if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
717 FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
718 /* shall we consider the END flag for the closing loop or for
719 * the opening one or for both ???
720 * code assumes for closing loop only
721 */
722 } else {
723 lpWaveHdr = lpWaveHdr->lpNext;
724 }
725 wwo->lpLoopPtr = NULL;
726 wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
727 }
728 } else {
729 /* We're not in a loop. Advance to the next wave header */
730 wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
731 }
732
733 return lpWaveHdr;
734 }
735
736 /**************************************************************************
737 * wodPlayer_DSPWait [internal]
738 * Returns the number of milliseconds to wait for the DSP buffer to play a
739 * period
740 */
741 static DWORD wodPlayer_DSPWait(const WINE_WAVEOUT *wwo)
742 {
743 /* time for one period to be played */
744 return snd_pcm_hw_params_get_period_time(wwo->hw_params, 0) / 1000;
745 }
746
747 /**************************************************************************
748 * wodPllayer_NotifyWait [internal]
749 * Returns the number of milliseconds to wait before attempting to notify
750 * completion of the specified wavehdr.
751 * This is based on the number of bytes remaining to be written in the
752 * wave.
753 */
754 static DWORD wodPlayer_NotifyWait(const WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
755 {
756 DWORD dwMillis;
757
758 dwMillis = (lpWaveHdr->dwBufferLength - lpWaveHdr->reserved) * 1000 / wwo->format.wf.nAvgBytesPerSec;
759 if (!dwMillis) dwMillis = 1;
760
761 return dwMillis;
762 }
763
764
765 /**************************************************************************
766 * wodPlayer_WriteMaxFrags [internal]
767 * Writes the maximum number of frames possible to the DSP and returns
768 * the number of frames written.
769 */
770 static int wodPlayer_WriteMaxFrags(WINE_WAVEOUT* wwo, DWORD* frames)
771 {
772 /* Only attempt to write to free frames */
773 LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
774 DWORD dwLength = snd_pcm_bytes_to_frames(wwo->p_handle, lpWaveHdr->dwBufferLength - lpWaveHdr->reserved);
775 int toWrite = min(dwLength, *frames);
776 int written;
777
778 TRACE("Writing wavehdr %p.%lu[%lu]\n", lpWaveHdr, lpWaveHdr->reserved, lpWaveHdr->dwBufferLength);
779
780 written = (wwo->write)(wwo->p_handle, lpWaveHdr->lpData + lpWaveHdr->reserved, toWrite);
781 if ( written < 0)
782 {
783 /* XRUN occurred. let's try to recover */
784 ALSA_XRUNRecovery(wwo, written);
785 written = (wwo->write)(wwo->p_handle, lpWaveHdr->lpData + lpWaveHdr->reserved, toWrite);
786 }
787 if (written <= 0)
788 {
789 /* still in error */
790 ERR("Error in writing wavehdr. Reason: %s\n", snd_strerror(written));
791 return written;
792 }
793
794 lpWaveHdr->reserved += snd_pcm_frames_to_bytes(wwo->p_handle, written);
795 if ( lpWaveHdr->reserved >= lpWaveHdr->dwBufferLength) {
796 /* this will be used to check if the given wave header has been fully played or not... */
797 lpWaveHdr->reserved = lpWaveHdr->dwBufferLength;
798 /* If we wrote all current wavehdr, skip to the next one */
799 wodPlayer_PlayPtrNext(wwo);
800 }
801 *frames -= written;
802 wwo->dwPlayedTotal += snd_pcm_frames_to_bytes(wwo->p_handle, written);
803
804 return written;
805 }
806
807
808 /**************************************************************************
809 * wodPlayer_NotifyCompletions [internal]
810 *
811 * Notifies and remove from queue all wavehdrs which have been played to
812 * the speaker (ie. they have cleared the ALSA buffer). If force is true,
813 * we notify all wavehdrs and remove them all from the queue even if they
814 * are unplayed or part of a loop.
815 */
816 static DWORD wodPlayer_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
817 {
818 LPWAVEHDR lpWaveHdr;
819
820 /* Start from lpQueuePtr and keep notifying until:
821 * - we hit an unwritten wavehdr
822 * - we hit the beginning of a running loop
823 * - we hit a wavehdr which hasn't finished playing
824 */
825 while ((lpWaveHdr = wwo->lpQueuePtr) &&
826 (force ||
827 (lpWaveHdr != wwo->lpPlayPtr &&
828 lpWaveHdr != wwo->lpLoopPtr &&
829 lpWaveHdr->reserved == lpWaveHdr->dwBufferLength))) {
830
831 wwo->lpQueuePtr = lpWaveHdr->lpNext;
832
833 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
834 lpWaveHdr->dwFlags |= WHDR_DONE;
835
836 wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
837 }
838 return (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != wwo->lpLoopPtr) ?
839 wodPlayer_NotifyWait(wwo, lpWaveHdr) : INFINITE;
840 }
841
842
843 void wait_for_poll(snd_pcm_t *handle, struct pollfd *ufds, unsigned int count)
844 {
845 unsigned short revents;
846
847 while (1) {
848 poll(ufds, count, -1);
849 snd_pcm_poll_descriptors_revents(handle, ufds, count, &revents);
850
851 if (revents & POLLERR)
852 return;
853
854 /*if (revents & POLLOUT)
855 return 0;*/
856 }
857 }
858
859
860 /**************************************************************************
861 * wodPlayer_Reset [internal]
862 *
863 * wodPlayer helper. Resets current output stream.
864 */
865 static void wodPlayer_Reset(WINE_WAVEOUT* wwo)
866 {
867 enum win_wm_message msg;
868 DWORD param;
869 HANDLE ev;
870 int err;
871
872 /* flush all possible output */
873 wait_for_poll(wwo->p_handle, wwo->ufds, wwo->count);
874
875 /* updates current notify list */
876 wodPlayer_NotifyCompletions(wwo, FALSE);
877
878 if ( (err = snd_pcm_drop(wwo->p_handle)) < 0) {
879 FIXME("flush: %s\n", snd_strerror(err));
880 wwo->hThread = 0;
881 wwo->state = WINE_WS_STOPPED;
882 ExitThread(-1);
883 }
884 if ( (err = snd_pcm_prepare(wwo->p_handle)) < 0 )
885 ERR("pcm prepare failed: %s\n", snd_strerror(err));
886
887 /* remove any buffer */
888 wodPlayer_NotifyCompletions(wwo, TRUE);
889
890 wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
891 wwo->state = WINE_WS_STOPPED;
892
893 /* remove any existing message in the ring */
894 EnterCriticalSection(&wwo->msgRing.msg_crst);
895 /* return all pending headers in queue */
896 while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev))
897 {
898 if (msg != WINE_WM_HEADER)
899 {
900 FIXME("shouldn't have headers left\n");
901 SetEvent(ev);
902 continue;
903 }
904 ((LPWAVEHDR)param)->dwFlags &= ~WHDR_INQUEUE;
905 ((LPWAVEHDR)param)->dwFlags |= WHDR_DONE;
906
907 wodNotifyClient(wwo, WOM_DONE, param, 0);
908 }
909 ResetEvent(wwo->msgRing.msg_event);
910 LeaveCriticalSection(&wwo->msgRing.msg_crst);
911 }
912
913 /**************************************************************************
914 * wodPlayer_ProcessMessages [internal]
915 */
916 static void wodPlayer_ProcessMessages(WINE_WAVEOUT* wwo)
917 {
918 LPWAVEHDR lpWaveHdr;
919 enum win_wm_message msg;
920 DWORD param;
921 HANDLE ev;
922 int err;
923
924 while (ALSA_RetrieveRingMessage(&wwo->msgRing, &msg, &param, &ev)) {
925 /* TRACE("Received %s %lx\n", wodPlayerCmdString[msg - WM_USER - 1], param); */
926
927 switch (msg) {
928 case WINE_WM_PAUSING:
929 if ( snd_pcm_state(wwo->p_handle) == SND_PCM_STATE_RUNNING )
930 {
931 err = snd_pcm_pause(wwo->p_handle, 1);
932 if ( err < 0 )
933 ERR("pcm_pause failed: %s\n", snd_strerror(err));
934 }
935 wwo->state = WINE_WS_PAUSED;
936 SetEvent(ev);
937 break;
938 case WINE_WM_RESTARTING:
939 if (wwo->state == WINE_WS_PAUSED)
940 {
941 if ( snd_pcm_state(wwo->p_handle) == SND_PCM_STATE_PAUSED )
942 {
943 err = snd_pcm_pause(wwo->p_handle, 0);
944 if ( err < 0 )
945 ERR("pcm_pause failed: %s\n", snd_strerror(err));
946 }
947 wwo->state = WINE_WS_PLAYING;
948 }
949 SetEvent(ev);
950 break;
951 case WINE_WM_HEADER:
952 lpWaveHdr = (LPWAVEHDR)param;
953
954 /* insert buffer at the end of queue */
955 {
956 LPWAVEHDR* wh;
957 for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
958 *wh = lpWaveHdr;
959 }
960 if (!wwo->lpPlayPtr)
961 wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
962 if (wwo->state == WINE_WS_STOPPED)
963 wwo->state = WINE_WS_PLAYING;
964 break;
965 case WINE_WM_RESETTING:
966 wodPlayer_Reset(wwo);
967 SetEvent(ev);
968 break;
969 case WINE_WM_UPDATE:
970 wodUpdatePlayedTotal(wwo, NULL);
971 SetEvent(ev);
972 break;
973 case WINE_WM_BREAKLOOP:
974 if (wwo->state == WINE_WS_PLAYING && wwo->lpLoopPtr != NULL) {
975 /* ensure exit at end of current loop */
976 wwo->dwLoops = 1;
977 }
978 SetEvent(ev);
979 break;
980 case WINE_WM_CLOSING:
981 /* sanity check: this should not happen since the device must have been reset before */
982 if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
983 wwo->hThread = 0;
984 wwo->state = WINE_WS_CLOSED;
985 SetEvent(ev);
986 ExitThread(0);
987 /* shouldn't go here */
988 default:
989 FIXME("unknown message %d\n", msg);
990 break;
991 }
992 }
993 }
994
995 /**************************************************************************
996 * wodPlayer_FeedDSP [internal]
997 * Feed as much sound data as we can into the DSP and return the number of
998 * milliseconds before it will be necessary to feed the DSP again.
999 */
1000 static DWORD wodPlayer_FeedDSP(WINE_WAVEOUT* wwo)
1001 {
1002 DWORD availInQ = snd_pcm_avail_update(wwo->p_handle);
1003
1004 /* no more room... no need to try to feed */
1005 while (wwo->lpPlayPtr && availInQ > 0)
1006 if ( wodPlayer_WriteMaxFrags(wwo, &availInQ) < 0 )
1007 break;
1008
1009 return wodPlayer_DSPWait(wwo);
1010 }
1011
1012 /**************************************************************************
1013 * wodPlayer [internal]
1014 */
1015 static DWORD CALLBACK wodPlayer(LPVOID pmt)
1016 {
1017 WORD uDevID = (DWORD)pmt;
1018 WINE_WAVEOUT* wwo = (WINE_WAVEOUT*)&WOutDev[uDevID];
1019 DWORD dwNextFeedTime = INFINITE; /* Time before DSP needs feeding */
1020 DWORD dwNextNotifyTime = INFINITE; /* Time before next wave completion */
1021 DWORD dwSleepTime;
1022
1023 wwo->state = WINE_WS_STOPPED;
1024 SetEvent(wwo->hStartUpEvent);
1025
1026 for (;;) {
1027 /** Wait for the shortest time before an action is required. If there
1028 * are no pending actions, wait forever for a command.
1029 */
1030 dwSleepTime = min(dwNextFeedTime, dwNextNotifyTime);
1031 TRACE("waiting %lums (%lu,%lu)\n", dwSleepTime, dwNextFeedTime, dwNextNotifyTime);
1032 WaitForSingleObject(wwo->msgRing.msg_event, dwSleepTime);
1033 wodPlayer_ProcessMessages(wwo);
1034 if (wwo->state == WINE_WS_PLAYING) {
1035 dwNextFeedTime = wodPlayer_FeedDSP(wwo);
1036 dwNextNotifyTime = wodPlayer_NotifyCompletions(wwo, FALSE);
1037 } else {
1038 dwNextFeedTime = dwNextNotifyTime = INFINITE;
1039 }
1040 }
1041 }
1042
1043 /**************************************************************************
1044 * wodGetDevCaps [internal]
1045 */
1046 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSA lpCaps, DWORD dwSize)
1047 {
1048 TRACE("(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
1049
1050 if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1051
1052 if (wDevID >= MAX_WAVEOUTDRV) {
1053 TRACE("MAX_WAVOUTDRV reached !\n");
1054 return MMSYSERR_BADDEVICEID;
1055 }
1056
1057 memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1058 return MMSYSERR_NOERROR;
1059 }
1060
1061 /**************************************************************************
1062 * wodOpen [internal]
1063 */
1064 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1065 {
1066 WINE_WAVEOUT* wwo;
1067 snd_pcm_hw_params_t * hw_params;
1068 snd_pcm_sw_params_t * sw_params;
1069 snd_pcm_access_t access;
1070 snd_pcm_format_t format;
1071 int rate;
1072 unsigned int buffer_time = 500000;
1073 unsigned int period_time = 10000;
1074 int buffer_size;
1075 snd_pcm_uframes_t period_size;
1076 int flags;
1077 snd_pcm_t * pcm;
1078 int err;
1079
1080 snd_pcm_hw_params_alloca(&hw_params);
1081 snd_pcm_sw_params_alloca(&sw_params);
1082
1083 TRACE("(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
1084 if (lpDesc == NULL) {
1085 WARN("Invalid Parameter !\n");
1086 return MMSYSERR_INVALPARAM;
1087 }
1088 if (wDevID >= MAX_WAVEOUTDRV) {
1089 TRACE("MAX_WAVOUTDRV reached !\n");
1090 return MMSYSERR_BADDEVICEID;
1091 }
1092
1093 /* only PCM format is supported so far... */
1094 if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1095 lpDesc->lpFormat->nChannels == 0 ||
1096 lpDesc->lpFormat->nSamplesPerSec == 0) {
1097 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1098 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1099 lpDesc->lpFormat->nSamplesPerSec);
1100 return WAVERR_BADFORMAT;
1101 }
1102
1103 if (dwFlags & WAVE_FORMAT_QUERY) {
1104 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%ld !\n",
1105 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1106 lpDesc->lpFormat->nSamplesPerSec);
1107 return MMSYSERR_NOERROR;
1108 }
1109
1110 wwo = &WOutDev[wDevID];
1111
1112 if ((dwFlags & WAVE_DIRECTSOUND) && !(wwo->caps.dwSupport & WAVECAPS_DIRECTSOUND))
1113 /* not supported, ignore it */
1114 dwFlags &= ~WAVE_DIRECTSOUND;
1115
1116 wwo->p_handle = 0;
1117 flags = SND_PCM_NONBLOCK;
1118 if ( dwFlags & WAVE_DIRECTSOUND )
1119 flags |= SND_PCM_ASYNC;
1120
1121 if (snd_pcm_open(&pcm, wwo->device, SND_PCM_STREAM_PLAYBACK, dwFlags))
1122 {
1123 ERR("Error open: %s\n", snd_strerror(errno));
1124 return MMSYSERR_NOTENABLED;
1125 }
1126
1127 wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1128
1129 memcpy(&wwo->waveDesc, lpDesc, sizeof(WAVEOPENDESC));
1130 memcpy(&wwo->format, lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
1131
1132 if (wwo->format.wBitsPerSample == 0) {
1133 WARN("Resetting zeroed wBitsPerSample\n");
1134 wwo->format.wBitsPerSample = 8 *
1135 (wwo->format.wf.nAvgBytesPerSec /
1136 wwo->format.wf.nSamplesPerSec) /
1137 wwo->format.wf.nChannels;
1138 }
1139
1140 snd_pcm_hw_params_any(pcm, hw_params);
1141
1142 #define EXIT_ON_ERROR(f,e,txt) do \
1143 { \
1144 int err; \
1145 if ( (err = (f) ) < 0) \
1146 { \
1147 ERR(txt ": %s\n", snd_strerror(err)); \
1148 snd_pcm_close(pcm); \
1149 return e; \
1150 } \
1151 } while(0)
1152
1153 access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
1154 if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
1155 WARN("mmap not available. switching to standard write.\n");
1156 access = SND_PCM_ACCESS_RW_INTERLEAVED;
1157 EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
1158 wwo->write = snd_pcm_writei;
1159 }
1160 else
1161 wwo->write = snd_pcm_mmap_writei;
1162
1163 EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwo->format.wf.nChannels), MMSYSERR_INVALPARAM, "unable to set required channels");
1164
1165 format = (wwo->format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE : SND_PCM_FORMAT_U8;
1166 EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), MMSYSERR_INVALPARAM, "unable to set required format");
1167
1168 rate = snd_pcm_hw_params_set_rate_near(pcm, hw_params, wwo->format.wf.nSamplesPerSec, 0);
1169 if (rate < 0) {
1170 ERR("Rate %ld Hz not available for playback: %s\n", wwo->format.wf.nSamplesPerSec, snd_strerror(rate));
1171 snd_pcm_close(pcm);
1172 return WAVERR_BADFORMAT;
1173 }
1174 if (rate != wwo->format.wf.nSamplesPerSec) {
1175 ERR("Rate doesn't match (requested %ld Hz, got %d Hz)\n", wwo->format.wf.nSamplesPerSec, rate);
1176 snd_pcm_close(pcm);
1177 return WAVERR_BADFORMAT;
1178 }
1179
1180 EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, buffer_time, 0), MMSYSERR_INVALPARAM, "unable to set buffer time");
1181 EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm, hw_params, period_time, 0), MMSYSERR_INVALPARAM, "unable to set period time");
1182
1183 EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
1184
1185 period_size = snd_pcm_hw_params_get_period_size(hw_params, 0);
1186 buffer_size = snd_pcm_hw_params_get_buffer_size(hw_params);
1187
1188 snd_pcm_sw_params_current(pcm, sw_params);
1189 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");
1190 EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence size");
1191 EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
1192 EXIT_ON_ERROR( snd_pcm_sw_params_set_xfer_align(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set xfer align");
1193 EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
1194 EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
1195 #undef EXIT_ON_ERROR
1196
1197 snd_pcm_prepare(pcm);
1198
1199 if (TRACE_ON(wave))
1200 ALSA_TraceParameters(hw_params, sw_params, FALSE);
1201
1202 /* now, we can save all required data for later use... */
1203 if ( wwo->hw_params )
1204 snd_pcm_hw_params_free(wwo->hw_params);
1205 snd_pcm_hw_params_malloc(&(wwo->hw_params));
1206 snd_pcm_hw_params_copy(wwo->hw_params, hw_params);
1207
1208 wwo->dwBufferSize = buffer_size;
1209 wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
1210 wwo->p_handle = pcm;
1211
1212 ALSA_InitRingMessage(&wwo->msgRing);
1213
1214 wwo->count = snd_pcm_poll_descriptors_count (wwo->p_handle);
1215 if (wwo->count <= 0) {
1216 ERR("Invalid poll descriptors count\n");
1217 return MMSYSERR_ERROR;
1218 }
1219
1220 wwo->ufds = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(struct pollfd) * wwo->count);
1221 if (wwo->ufds == NULL) {
1222 ERR("No enough memory\n");
1223 return MMSYSERR_NOMEM;
1224 }
1225 if ((err = snd_pcm_poll_descriptors(wwo->p_handle, wwo->ufds, wwo->count)) < 0) {
1226 ERR("Unable to obtain poll descriptors for playback: %s\n", snd_strerror(err));
1227 return MMSYSERR_ERROR;
1228 }
1229
1230 if (!(dwFlags & WAVE_DIRECTSOUND)) {
1231 wwo->hStartUpEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1232 wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD)wDevID, 0, &(wwo->dwThreadID));
1233 WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
1234 CloseHandle(wwo->hStartUpEvent);
1235 } else {
1236 wwo->hThread = INVALID_HANDLE_VALUE;
1237 wwo->dwThreadID = 0;
1238 }
1239 wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
1240
1241 TRACE("handle=%08lx \n", (DWORD)wwo->p_handle);
1242 /* if (wwo->dwFragmentSize % wwo->format.wf.nBlockAlign)
1243 ERR("Fragment doesn't contain an integral number of data blocks\n");
1244 */
1245 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%lu, nSamplesPerSec=%lu, nChannels=%u nBlockAlign=%u!\n",
1246 wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec,
1247 wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1248 wwo->format.wf.nBlockAlign);
1249
1250 return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
1251 }
1252
1253
1254 /**************************************************************************
1255 * wodClose [internal]
1256 */
1257 static DWORD wodClose(WORD wDevID)
1258 {
1259 DWORD ret = MMSYSERR_NOERROR;
1260 WINE_WAVEOUT* wwo;
1261
1262 TRACE("(%u);\n", wDevID);
1263
1264 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1265 WARN("bad device ID !\n");
1266 return MMSYSERR_BADDEVICEID;
1267 }
1268
1269 wwo = &WOutDev[wDevID];
1270 if (wwo->lpQueuePtr) {
1271 WARN("buffers still playing !\n");
1272 ret = WAVERR_STILLPLAYING;
1273 } else {
1274 if (wwo->hThread != INVALID_HANDLE_VALUE) {
1275 ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_CLOSING, 0, TRUE);
1276 }
1277 ALSA_DestroyRingMessage(&wwo->msgRing);
1278
1279 snd_pcm_hw_params_free(wwo->hw_params);
1280 wwo->hw_params = NULL;
1281
1282 snd_pcm_close(wwo->p_handle);
1283 wwo->p_handle = NULL;
1284
1285 ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
1286 }
1287
1288 HeapFree(GetProcessHeap(), 0, wwo->ufds);
1289 return ret;
1290 }
1291
1292
1293 /**************************************************************************
1294 * wodWrite [internal]
1295 *
1296 */
1297 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1298 {
1299 TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1300
1301 /* first, do the sanity checks... */
1302 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1303 WARN("bad dev ID !\n");
1304 return MMSYSERR_BADDEVICEID;
1305 }
1306
1307 if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
1308 return WAVERR_UNPREPARED;
1309
1310 if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1311 return WAVERR_STILLPLAYING;
1312
1313 lpWaveHdr->dwFlags &= ~WHDR_DONE;
1314 lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1315 lpWaveHdr->lpNext = 0;
1316
1317 ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
1318
1319 return MMSYSERR_NOERROR;
1320 }
1321
1322 /**************************************************************************
1323 * wodPrepare [internal]
1324 */
1325 static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1326 {
1327 TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1328
1329 if (wDevID >= MAX_WAVEOUTDRV) {
1330 WARN("bad device ID !\n");
1331 return MMSYSERR_BADDEVICEID;
1332 }
1333
1334 if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1335 return WAVERR_STILLPLAYING;
1336
1337 lpWaveHdr->dwFlags |= WHDR_PREPARED;
1338 lpWaveHdr->dwFlags &= ~WHDR_DONE;
1339 return MMSYSERR_NOERROR;
1340 }
1341
1342 /**************************************************************************
1343 * wodUnprepare [internal]
1344 */
1345 static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1346 {
1347 TRACE("(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1348
1349 if (wDevID >= MAX_WAVEOUTDRV) {
1350 WARN("bad device ID !\n");
1351 return MMSYSERR_BADDEVICEID;
1352 }
1353
1354 if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1355 return WAVERR_STILLPLAYING;
1356
1357 lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
1358 lpWaveHdr->dwFlags |= WHDR_DONE;
1359
1360 return MMSYSERR_NOERROR;
1361 }
1362
1363 /**************************************************************************
1364 * wodPause [internal]
1365 */
1366 static DWORD wodPause(WORD wDevID)
1367 {
1368 TRACE("(%u);!\n", wDevID);
1369
1370 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1371 WARN("bad device ID !\n");
1372 return MMSYSERR_BADDEVICEID;
1373 }
1374
1375 ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_PAUSING, 0, TRUE);
1376
1377 return MMSYSERR_NOERROR;
1378 }
1379
1380 /**************************************************************************
1381 * wodRestart [internal]
1382 */
1383 static DWORD wodRestart(WORD wDevID)
1384 {
1385 TRACE("(%u);\n", wDevID);
1386
1387 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1388 WARN("bad device ID !\n");
1389 return MMSYSERR_BADDEVICEID;
1390 }
1391
1392 if (WOutDev[wDevID].state == WINE_WS_PAUSED) {
1393 ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESTARTING, 0, TRUE);
1394 }
1395
1396 /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
1397 /* FIXME: Myst crashes with this ... hmm -MM
1398 return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
1399 */
1400
1401 return MMSYSERR_NOERROR;
1402 }
1403
1404 /**************************************************************************
1405 * wodReset [internal]
1406 */
1407 static DWORD wodReset(WORD wDevID)
1408 {
1409 TRACE("(%u);\n", wDevID);
1410
1411 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1412 WARN("bad device ID !\n");
1413 return MMSYSERR_BADDEVICEID;
1414 }
1415
1416 ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_RESETTING, 0, TRUE);
1417
1418 return MMSYSERR_NOERROR;
1419 }
1420
1421 /**************************************************************************
1422 * wodGetPosition [internal]
1423 */
1424 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1425 {
1426 int time;
1427 DWORD val;
1428 WINE_WAVEOUT* wwo;
1429
1430 TRACE("(%u, %p, %lu);\n", wDevID, lpTime, uSize);
1431
1432 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1433 WARN("bad device ID !\n");
1434 return MMSYSERR_BADDEVICEID;
1435 }
1436
1437 if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1438
1439 wwo = &WOutDev[wDevID];
1440 ALSA_AddRingMessage(&wwo->msgRing, WINE_WM_UPDATE, 0, TRUE);
1441 val = wwo->dwPlayedTotal;
1442
1443 TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%lu nChannels=%u nAvgBytesPerSec=%lu\n",
1444 lpTime->wType, wwo->format.wBitsPerSample,
1445 wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1446 wwo->format.wf.nAvgBytesPerSec);
1447 TRACE("dwPlayedTotal=%lu\n", val);
1448
1449 switch (lpTime->wType) {
1450 case TIME_BYTES:
1451 lpTime->u.cb = val;
1452 TRACE("TIME_BYTES=%lu\n", lpTime->u.cb);
1453 break;
1454 case TIME_SAMPLES:
1455 lpTime->u.sample = val * 8 / wwo->format.wBitsPerSample /wwo->format.wf.nChannels;
1456 TRACE("TIME_SAMPLES=%lu\n", lpTime->u.sample);
1457 break;
1458 case TIME_SMPTE:
1459 time = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
1460 lpTime->u.smpte.hour = time / 108000;
1461 time -= lpTime->u.smpte.hour * 108000;
1462 lpTime->u.smpte.min = time / 1800;
1463 time -= lpTime->u.smpte.min * 1800;
1464 lpTime->u.smpte.sec = time / 30;
1465 time -= lpTime->u.smpte.sec * 30;
1466 lpTime->u.smpte.frame = time;
1467 lpTime->u.smpte.fps = 30;
1468 TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
1469 lpTime->u.smpte.hour, lpTime->u.smpte.min,
1470 lpTime->u.smpte.sec, lpTime->u.smpte.frame);
1471 break;
1472 default:
1473 FIXME("Format %d not supported ! use TIME_MS !\n", lpTime->wType);
1474 lpTime->wType = TIME_MS;
1475 case TIME_MS:
1476 lpTime->u.ms = val / (wwo->format.wf.nAvgBytesPerSec / 1000);
1477 TRACE("TIME_MS=%lu\n", lpTime->u.ms);
1478 break;
1479 }
1480 return MMSYSERR_NOERROR;
1481 }
1482
1483 /**************************************************************************
1484 * wodBreakLoop [internal]
1485 */
1486 static DWORD wodBreakLoop(WORD wDevID)
1487 {
1488 TRACE("(%u);\n", wDevID);
1489
1490 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1491 WARN("bad device ID !\n");
1492 return MMSYSERR_BADDEVICEID;
1493 }
1494 ALSA_AddRingMessage(&WOutDev[wDevID].msgRing, WINE_WM_BREAKLOOP, 0, TRUE);
1495 return MMSYSERR_NOERROR;
1496 }
1497
1498 /**************************************************************************
1499 * wodGetVolume [internal]
1500 */
1501 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1502 {
1503 WORD left, right;
1504 WINE_WAVEOUT* wwo;
1505 int count;
1506 long min, max;
1507
1508 TRACE("(%u, %p);\n", wDevID, lpdwVol);
1509 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1510 WARN("bad device ID !\n");
1511 return MMSYSERR_BADDEVICEID;
1512 }
1513 wwo = &WOutDev[wDevID];
1514 count = snd_ctl_elem_info_get_count(wwo->playback_einfo);
1515 min = snd_ctl_elem_info_get_min(wwo->playback_einfo);
1516 max = snd_ctl_elem_info_get_max(wwo->playback_einfo);
1517
1518 #define VOLUME_ALSA_TO_WIN(x) (((x)-min) * 65536 /(max-min))
1519 if (lpdwVol == NULL)
1520 return MMSYSERR_NOTENABLED;
1521
1522 switch (count)
1523 {
1524 case 2:
1525 left = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 0));
1526 right = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 1));
1527 break;
1528 case 1:
1529 left = right = VOLUME_ALSA_TO_WIN(snd_ctl_elem_value_get_integer(wwo->playback_evalue, 0));
1530 break;
1531 default:
1532 WARN("%d channels mixer not supported\n", count);
1533 return MMSYSERR_NOERROR;
1534 }
1535 #undef VOLUME_ALSA_TO_WIN
1536
1537 TRACE("left=%d right=%d !\n", left, right);
1538 *lpdwVol = MAKELONG( left, right );
1539 return MMSYSERR_NOERROR;
1540 }
1541
1542 /**************************************************************************
1543 * wodSetVolume [internal]
1544 */
1545 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1546 {
1547 WORD left, right;
1548 WINE_WAVEOUT* wwo;
1549 int count, err;
1550 long min, max;
1551
1552 TRACE("(%u, %08lX);\n", wDevID, dwParam);
1553 if (wDevID >= MAX_WAVEOUTDRV || WOutDev[wDevID].p_handle == NULL) {
1554 WARN("bad device ID !\n");
1555 return MMSYSERR_BADDEVICEID;
1556 }
1557 wwo = &WOutDev[wDevID];
1558 count=snd_ctl_elem_info_get_count(wwo->playback_einfo);
1559 min = snd_ctl_elem_info_get_min(wwo->playback_einfo);
1560 max = snd_ctl_elem_info_get_max(wwo->playback_einfo);
1561
1562 left = LOWORD(dwParam);
1563 right = HIWORD(dwParam);
1564
1565 #define VOLUME_WIN_TO_ALSA(x) ( (((x) * (max-min)) / 65536) + min )
1566 switch (count)
1567 {
1568 case 2:
1569 snd_ctl_elem_value_set_integer(wwo->playback_evalue, 0, VOLUME_WIN_TO_ALSA(left));
1570 snd_ctl_elem_value_set_integer(wwo->playback_evalue, 1, VOLUME_WIN_TO_ALSA(right));
1571 break;
1572 case 1:
1573 snd_ctl_elem_value_set_integer(wwo->playback_evalue, 0, VOLUME_WIN_TO_ALSA(left));
1574 break;
1575 default:
1576 WARN("%d channels mixer not supported\n", count);
1577 }
1578 #undef VOLUME_WIN_TO_ALSA
1579 if ( (err = snd_ctl_elem_write(wwo->ctl, wwo->playback_evalue)) < 0)
1580 {
1581 ERR("error writing snd_ctl_elem_value: %s\n", snd_strerror(err));
1582 }
1583 return MMSYSERR_NOERROR;
1584 }
1585
1586 /**************************************************************************
1587 * wodGetNumDevs [internal]
1588 */
1589 static DWORD wodGetNumDevs(void)
1590 {
1591 return ALSA_WodNumDevs;
1592 }
1593
1594
1595 /**************************************************************************
1596 * wodMessage (WINEALSA.@)
1597 */
1598 DWORD WINAPI ALSA_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1599 DWORD dwParam1, DWORD dwParam2)
1600 {
1601 TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
1602 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1603
1604 switch (wMsg) {
1605 case DRVM_INIT:
1606 case DRVM_EXIT:
1607 case DRVM_ENABLE:
1608 case DRVM_DISABLE:
1609 /* FIXME: Pretend this is supported */
1610 return 0;
1611 case WODM_OPEN: return wodOpen (wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
1612 case WODM_CLOSE: return wodClose (wDevID);
1613 case WODM_GETDEVCAPS: return wodGetDevCaps (wDevID, (LPWAVEOUTCAPSA)dwParam1, dwParam2);
1614 case WODM_GETNUMDEVS: return wodGetNumDevs ();
1615 case WODM_GETPITCH: return MMSYSERR_NOTSUPPORTED;
1616 case WODM_SETPITCH: return MMSYSERR_NOTSUPPORTED;
1617 case WODM_GETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
1618 case WODM_SETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
1619 case WODM_WRITE: return wodWrite (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
1620 case WODM_PAUSE: return wodPause (wDevID);
1621 case WODM_GETPOS: return wodGetPosition (wDevID, (LPMMTIME)dwParam1, dwParam2);
1622 case WODM_BREAKLOOP: return wodBreakLoop (wDevID);
1623 case WODM_PREPARE: return wodPrepare (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
1624 case WODM_UNPREPARE: return wodUnprepare (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
1625 case WODM_GETVOLUME: return wodGetVolume (wDevID, (LPDWORD)dwParam1);
1626 case WODM_SETVOLUME: return wodSetVolume (wDevID, dwParam1);
1627 case WODM_RESTART: return wodRestart (wDevID);
1628 case WODM_RESET: return wodReset (wDevID);
1629 case DRV_QUERYDSOUNDIFACE: return wodDsCreate (wDevID, (PIDSDRIVER*)dwParam1);
1630 case DRV_QUERYDSOUNDDESC: return wodDsDesc (wDevID, (PDSDRIVERDESC)dwParam1);
1631 case DRV_QUERYDSOUNDGUID: return wodDsGuid (wDevID, (LPGUID)dwParam1);
1632
1633 default:
1634 FIXME("unknown message %d!\n", wMsg);
1635 }
1636 return MMSYSERR_NOTSUPPORTED;
1637 }
1638
1639 /*======================================================================*
1640 * Low level DSOUND implementation *
1641 *======================================================================*/
1642
1643 typedef struct IDsDriverImpl IDsDriverImpl;
1644 typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
1645
1646 struct IDsDriverImpl
1647 {
1648 /* IUnknown fields */
1649 ICOM_VFIELD(IDsDriver);
1650 DWORD ref;
1651 /* IDsDriverImpl fields */
1652 UINT wDevID;
1653 IDsDriverBufferImpl*primary;
1654 };
1655
1656 struct IDsDriverBufferImpl
1657 {
1658 /* IUnknown fields */
1659 ICOM_VFIELD(IDsDriverBuffer);
1660 DWORD ref;
1661 /* IDsDriverBufferImpl fields */
1662 IDsDriverImpl* drv;
1663
1664 CRITICAL_SECTION mmap_crst;
1665 LPVOID mmap_buffer;
1666 DWORD mmap_buflen_bytes;
1667 snd_pcm_uframes_t mmap_buflen_frames;
1668 snd_pcm_channel_area_t * mmap_areas;
1669 snd_async_handler_t * mmap_async_handler;
1670 };
1671
1672 static void DSDB_CheckXRUN(IDsDriverBufferImpl* pdbi)
1673 {
1674 WINE_WAVEOUT * wwo = &(WOutDev[pdbi->drv->wDevID]);
1675 snd_pcm_state_t state = snd_pcm_state(wwo->p_handle);
1676
1677 if ( state == SND_PCM_STATE_XRUN )
1678 {
1679 int err = snd_pcm_prepare(wwo->p_handle);
1680 TRACE("xrun occurred\n");
1681 if ( err < 0 )
1682 ERR("recovery from xrun failed, prepare failed: %s\n", snd_strerror(err));
1683 }
1684 else if ( state == SND_PCM_STATE_SUSPENDED )
1685 {
1686 int err = snd_pcm_resume(wwo->p_handle);
1687 TRACE("recovery from suspension occurred\n");
1688 if (err < 0 && err != -EAGAIN){
1689 err = snd_pcm_prepare(wwo->p_handle);
1690 if (err < 0)
1691 ERR("recovery from suspend failed, prepare failed: %s\n", snd_strerror(err));
1692 }
1693 }
1694 }
1695
1696 static void DSDB_MMAPCopy(IDsDriverBufferImpl* pdbi)
1697 {
1698 WINE_WAVEOUT * wwo = &(WOutDev[pdbi->drv->wDevID]);
1699 int channels;
1700 snd_pcm_format_t format;
1701 snd_pcm_uframes_t period_size;
1702 snd_pcm_sframes_t avail;
1703
1704 if ( !pdbi->mmap_buffer || !wwo->hw_params || !wwo->p_handle)
1705 return;
1706
1707 channels = snd_pcm_hw_params_get_channels(wwo->hw_params);
1708 format = snd_pcm_hw_params_get_format(wwo->hw_params);
1709 period_size = snd_pcm_hw_params_get_period_size(wwo->hw_params, 0);
1710 avail = snd_pcm_avail_update(wwo->p_handle);
1711
1712 DSDB_CheckXRUN(pdbi);
1713
1714 TRACE("avail=%d format=%s channels=%d\n", (int)avail, snd_pcm_format_name(format), channels );
1715
1716 while (avail >= period_size)
1717 {
1718 const snd_pcm_channel_area_t *areas;
1719 snd_pcm_uframes_t ofs;
1720 snd_pcm_uframes_t frames;
1721 int err;
1722
1723 frames = avail / period_size * period_size; /* round down to a multiple of period_size */
1724
1725 EnterCriticalSection(&pdbi->mmap_crst);
1726
1727 snd_pcm_mmap_begin(wwo->p_handle, &areas, &ofs, &frames);
1728 snd_pcm_areas_copy(areas, ofs, pdbi->mmap_areas, ofs, channels, frames, format);
1729 err = snd_pcm_mmap_commit(wwo->p_handle, ofs, frames);
1730
1731 LeaveCriticalSection(&pdbi->mmap_crst);
1732
1733 if ( err != (snd_pcm_sframes_t) frames)
1734 ERR("mmap partially failed.\n");
1735
1736 avail = snd_pcm_avail_update(wwo->p_handle);
1737 }
1738 }
1739
1740 static void DSDB_PCMCallback(snd_async_handler_t *ahandler)
1741 {
1742 /* snd_pcm_t * handle = snd_async_handler_get_pcm(ahandler); */
1743 IDsDriverBufferImpl* pdbi = snd_async_handler_get_callback_private(ahandler);
1744 TRACE("callback called\n");
1745 DSDB_MMAPCopy(pdbi);
1746 }
1747
1748 static int DSDB_CreateMMAP(IDsDriverBufferImpl* pdbi)
1749 {
1750 WINE_WAVEOUT * wwo = &(WOutDev[pdbi->drv->wDevID]);
1751 snd_pcm_format_t format = snd_pcm_hw_params_get_format(wwo->hw_params);
1752 snd_pcm_uframes_t frames = snd_pcm_hw_params_get_buffer_size(wwo->hw_params);
1753 int channels = snd_pcm_hw_params_get_channels(wwo->hw_params);
1754 unsigned int bits_per_sample = snd_pcm_format_physical_width(format);
1755 unsigned int bits_per_frame = bits_per_sample * channels;
1756 snd_pcm_channel_area_t * a;
1757 unsigned int c;
1758 int err;
1759
1760 if (TRACE_ON(wave))
1761 ALSA_TraceParameters(wwo->hw_params, NULL, FALSE);
1762
1763 TRACE("format=%s frames=%ld channels=%d bits_per_sample=%d bits_per_frame=%d\n",
1764 snd_pcm_format_name(format), frames, channels, bits_per_sample, bits_per_frame);
1765
1766 pdbi->mmap_buflen_frames = frames;
1767 pdbi->mmap_buflen_bytes = snd_pcm_frames_to_bytes( wwo->p_handle, frames );
1768 pdbi->mmap_buffer = HeapAlloc(GetProcessHeap(),0,pdbi->mmap_buflen_bytes);
1769 if (!pdbi->mmap_buffer)
1770 return DSERR_OUTOFMEMORY;
1771
1772 snd_pcm_format_set_silence(format, pdbi->mmap_buffer, frames );
1773
1774 TRACE("created mmap buffer of %ld frames (%ld bytes) at %p\n",
1775 frames, pdbi->mmap_buflen_bytes, pdbi->mmap_buffer);
1776
1777 pdbi->mmap_areas = HeapAlloc(GetProcessHeap(),0,channels*sizeof(snd_pcm_channel_area_t));
1778 if (!pdbi->mmap_areas)
1779 return DSERR_OUTOFMEMORY;
1780
1781 a = pdbi->mmap_areas;
1782 for (c = 0; c < channels; c++, a++)
1783 {
1784 a->addr = pdbi->mmap_buffer;
1785 a->first = bits_per_sample * c;
1786 a->step = bits_per_frame;
1787 TRACE("Area %d: addr=%p first=%d step=%d\n", c, a->addr, a->first, a->step);
1788 }
1789
1790 InitializeCriticalSection(&pdbi->mmap_crst);
1791
1792 err = snd_async_add_pcm_handler(&pdbi->mmap_async_handler, wwo->p_handle, DSDB_PCMCallback, pdbi);
1793 if ( err < 0 )
1794 {
1795 ERR("add_pcm_handler failed. reason: %s\n", snd_strerror(err));
1796 return DSERR_GENERIC;
1797 }
1798
1799 return DS_OK;
1800 }
1801
1802 static void DSDB_DestroyMMAP(IDsDriverBufferImpl* pdbi)
1803 {
1804 TRACE("mmap buffer %p destroyed\n", pdbi->mmap_buffer);
1805 HeapFree(GetProcessHeap(), 0, pdbi->mmap_areas);
1806 HeapFree(GetProcessHeap(), 0, pdbi->mmap_buffer);
1807 pdbi->mmap_areas = NULL;
1808 pdbi->mmap_buffer = NULL;
1809 DeleteCriticalSection(&pdbi->mmap_crst);
1810 }
1811
1812
1813 static HRESULT WINAPI IDsDriverBufferImpl_QueryInterface(PIDSDRIVERBUFFER iface, REFIID riid, LPVOID *ppobj)
1814 {
1815 /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1816 FIXME("(): stub!\n");
1817 return DSERR_UNSUPPORTED;
1818 }
1819
1820 static ULONG WINAPI IDsDriverBufferImpl_AddRef(PIDSDRIVERBUFFER iface)
1821 {
1822 ICOM_THIS(IDsDriverBufferImpl,iface);
1823 TRACE("(%p)\n",iface);
1824 return ++This->ref;
1825 }
1826
1827 static ULONG WINAPI IDsDriverBufferImpl_Release(PIDSDRIVERBUFFER iface)
1828 {
1829 ICOM_THIS(IDsDriverBufferImpl,iface);
1830 TRACE("(%p)\n",iface);
1831 if (--This->ref)
1832 return This->ref;
1833 if (This == This->drv->primary)
1834 This->drv->primary = NULL;
1835 DSDB_DestroyMMAP(This);
1836 HeapFree(GetProcessHeap(), 0, This);
1837 return 0;
1838 }
1839
1840 static HRESULT WINAPI IDsDriverBufferImpl_Lock(PIDSDRIVERBUFFER iface,
1841 LPVOID*ppvAudio1,LPDWORD pdwLen1,
1842 LPVOID*ppvAudio2,LPDWORD pdwLen2,
1843 DWORD dwWritePosition,DWORD dwWriteLen,
1844 DWORD dwFlags)
1845 {
1846 /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1847 TRACE("(%p)\n",iface);
1848 return DSERR_UNSUPPORTED;
1849 }
1850
1851 static HRESULT WINAPI IDsDriverBufferImpl_Unlock(PIDSDRIVERBUFFER iface,
1852 LPVOID pvAudio1,DWORD dwLen1,
1853 LPVOID pvAudio2,DWORD dwLen2)
1854 {
1855 /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1856 TRACE("(%p)\n",iface);
1857 return DSERR_UNSUPPORTED;
1858 }
1859
1860 static HRESULT WINAPI IDsDriverBufferImpl_SetFormat(PIDSDRIVERBUFFER iface,
1861 LPWAVEFORMATEX pwfx)
1862 {
1863 /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1864 TRACE("(%p,%p)\n",iface,pwfx);
1865 return DSERR_BUFFERLOST;
1866 }
1867
1868 static HRESULT WINAPI IDsDriverBufferImpl_SetFrequency(PIDSDRIVERBUFFER iface, DWORD dwFreq)
1869 {
1870 /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1871 TRACE("(%p,%ld): stub\n",iface,dwFreq);
1872 return DSERR_UNSUPPORTED;
1873 }
1874
1875 static HRESULT WINAPI IDsDriverBufferImpl_SetVolumePan(PIDSDRIVERBUFFER iface, PDSVOLUMEPAN pVolPan)
1876 {
1877 /* ICOM_THIS(IDsDriverBufferImpl,iface); */
1878 FIXME("(%p,%p): stub!\n",iface,pVolPan);
1879 return DS_OK;
1880 }
1881
1882 static HRESULT WINAPI IDsDriverBufferImpl_SetPosition(PIDSDRIVERBUFFER iface, DWORD dwNewPos)
1883 {
1884 /* ICOM_THIS(IDsDriverImpl,iface); */
1885 TRACE("(%p,%ld): stub\n",iface,dwNewPos);
1886 return DSERR_UNSUPPORTED;
1887 }
1888
1889 static HRESULT WINAPI IDsDriverBufferImpl_GetPosition(PIDSDRIVERBUFFER iface,
1890 LPDWORD lpdwPlay, LPDWORD lpdwWrite)
1891 {
1892 ICOM_THIS(IDsDriverBufferImpl,iface);
1893 WINE_WAVEOUT * wwo = &(WOutDev[This->drv->wDevID]);
1894 snd_pcm_uframes_t hw_ptr;
1895 snd_pcm_uframes_t period_size;
1896
1897 if (wwo->hw_params == NULL) return DSERR_GENERIC;
1898
1899 period_size = snd_pcm_hw_params_get_period_size(wwo->hw_params, 0);
1900
1901 if (wwo->p_handle == NULL) return DSERR_GENERIC;
1902 /** we need to track down buffer underruns */
1903 DSDB_CheckXRUN(This);
1904
1905 EnterCriticalSection(&This->mmap_crst);
1906 hw_ptr = _snd_pcm_mmap_hw_ptr(wwo->p_handle);
1907 if (lpdwPlay)
1908 *lpdwPlay = snd_pcm_frames_to_bytes(wwo->p_handle, hw_ptr/ period_size * period_size) % This->mmap_buflen_bytes;
1909 if (lpdwWrite)
1910 *lpdwWrite = snd_pcm_frames_to_bytes(wwo->p_handle, (hw_ptr / period_size + 1) * period_size ) % This->mmap_buflen_bytes;
1911 LeaveCriticalSection(&This->mmap_crst);
1912
1913 TRACE("hw_ptr=0x%08x, playpos=%ld, writepos=%ld\n", (unsigned int)hw_ptr, lpdwPlay?*lpdwPlay:-1, lpdwWrite?*lpdwWrite:-1);
1914 return DS_OK;
1915 }
1916
1917 static HRESULT WINAPI IDsDriverBufferImpl_Play(PIDSDRIVERBUFFER iface, DWORD dwRes1, DWORD dwRes2, DWORD dwFlags)
1918 {
1919 ICOM_THIS(IDsDriverBufferImpl,iface);
1920 WINE_WAVEOUT * wwo = &(WOutDev[This->drv->wDevID]);
1921 snd_pcm_state_t state;
1922 int err;
1923
1924 TRACE("(%p,%lx,%lx,%lx)\n",iface,dwRes1,dwRes2,dwFlags);
1925
1926 if (wwo->p_handle == NULL) return DSERR_GENERIC;
1927
1928 state = snd_pcm_state(wwo->p_handle);
1929 if ( state == SND_PCM_STATE_SETUP )
1930 {
1931 err = snd_pcm_prepare(wwo->p_handle);
1932 state = snd_pcm_state(wwo->p_handle);
1933 }
1934 if ( state == SND_PCM_STATE_PREPARED )
1935 {
1936 DSDB_MMAPCopy(This);
1937 err = snd_pcm_start(wwo->p_handle);
1938 }
1939 return DS_OK;
1940 }
1941
1942 static HRESULT WINAPI IDsDriverBufferImpl_Stop(PIDSDRIVERBUFFER iface)
1943 {
1944 ICOM_THIS(IDsDriverBufferImpl,iface);
1945 WINE_WAVEOUT * wwo = &(WOutDev[This->drv->wDevID]);
1946 int err;
1947 DWORD play;
1948 DWORD write;
1949
1950 TRACE("(%p)\n",iface);
1951
1952 if (wwo->p_handle == NULL) return DSERR_GENERIC;
1953
1954 /* ring buffer wrap up detection */
1955 IDsDriverBufferImpl_GetPosition(iface, &play, &write);
1956 if ( play > write)
1957 {
1958 TRACE("writepos wrapper up\n");
1959 return DS_OK;
1960 }
1961
1962 if ( ( err = snd_pcm_drop(wwo->p_handle)) < 0 )
1963 {
1964 ERR("error while stopping pcm: %s\n", snd_strerror(err));
1965 return DSERR_GENERIC;
1966 }
1967 return DS_OK;
1968 }
1969
1970 static ICOM_VTABLE(IDsDriverBuffer) dsdbvt =
1971 {
1972 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1973 IDsDriverBufferImpl_QueryInterface,
1974 IDsDriverBufferImpl_AddRef,
1975 IDsDriverBufferImpl_Release,
1976 IDsDriverBufferImpl_Lock,
1977 IDsDriverBufferImpl_Unlock,
1978 IDsDriverBufferImpl_SetFormat,
1979 IDsDriverBufferImpl_SetFrequency,
1980 IDsDriverBufferImpl_SetVolumePan,
1981 IDsDriverBufferImpl_SetPosition,
1982 IDsDriverBufferImpl_GetPosition,
1983 IDsDriverBufferImpl_Play,
1984 IDsDriverBufferImpl_Stop
1985 };
1986
1987 static HRESULT WINAPI IDsDriverImpl_QueryInterface(PIDSDRIVER iface, REFIID riid, LPVOID *ppobj)
1988 {
1989 /* ICOM_THIS(IDsDriverImpl,iface); */
1990 FIXME("(%p): stub!\n",iface);
1991 return DSERR_UNSUPPORTED;
1992 }
1993
1994 static ULONG WINAPI IDsDriverImpl_AddRef(PIDSDRIVER iface)
1995 {
1996 ICOM_THIS(IDsDriverImpl,iface);
1997 TRACE("(%p)\n",iface);
1998 This->ref++;
1999 return This->ref;
2000 }
2001
2002 static ULONG WINAPI IDsDriverImpl_Release(PIDSDRIVER iface)
2003 {
2004 ICOM_THIS(IDsDriverImpl,iface);
2005 TRACE("(%p)\n",iface);
2006 if (--This->ref)
2007 return This->ref;
2008 HeapFree(GetProcessHeap(),0,This);
2009 return 0;
2010 }
2011
2012 static HRESULT WINAPI IDsDriverImpl_GetDriverDesc(PIDSDRIVER iface, PDSDRIVERDESC pDesc)
2013 {
2014 ICOM_THIS(IDsDriverImpl,iface);
2015 TRACE("(%p,%p)\n",iface,pDesc);
2016 memcpy(pDesc, &(WOutDev[This->wDevID].ds_desc), sizeof(DSDRIVERDESC));
2017 pDesc->dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT |
2018 DSDDESC_USESYSTEMMEMORY;
2019 pDesc->dnDevNode = WOutDev[This->wDevID].waveDesc.dnDevNode;
2020 pDesc->wVxdId = 0;
2021 pDesc->wReserved = 0;
2022 pDesc->ulDeviceNum = This->wDevID;
2023 pDesc->dwHeapType = DSDHEAP_NOHEAP;
2024 pDesc->pvDirectDrawHeap = NULL;
2025 pDesc->dwMemStartAddress = 0;
2026 pDesc->dwMemEndAddress = 0;
2027 pDesc->dwMemAllocExtra = 0;
2028 pDesc->pvReserved1 = NULL;
2029 pDesc->pvReserved2 = NULL;
2030 return DS_OK;
2031 }
2032
2033 static HRESULT WINAPI IDsDriverImpl_Open(PIDSDRIVER iface)
2034 {
2035 /* ICOM_THIS(IDsDriverImpl,iface); */
2036 TRACE("(%p)\n",iface);
2037 return DS_OK;
2038 }
2039
2040 static HRESULT WINAPI IDsDriverImpl_Close(PIDSDRIVER iface)
2041 {
2042 /* ICOM_THIS(IDsDriverImpl,iface); */
2043 TRACE("(%p)\n",iface);
2044 return DS_OK;
2045 }
2046
2047 static HRESULT WINAPI IDsDriverImpl_GetCaps(PIDSDRIVER iface, PDSDRIVERCAPS pCaps)
2048 {
2049 ICOM_THIS(IDsDriverImpl,iface);
2050 TRACE("(%p,%p)\n",iface,pCaps);
2051 memset(pCaps, 0, sizeof(*pCaps));
2052
2053 pCaps->dwFlags = DSCAPS_PRIMARYMONO;
2054 if ( WOutDev[This->wDevID].caps.wChannels == 2 )
2055 pCaps->dwFlags |= DSCAPS_PRIMARYSTEREO;
2056
2057 if ( WOutDev[This->wDevID].caps.dwFormats & (WAVE_FORMAT_1S08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_4S08 ) )
2058 pCaps->dwFlags |= DSCAPS_PRIMARY8BIT;
2059
2060 if ( WOutDev[This->wDevID].caps.dwFormats & (WAVE_FORMAT_1S16 | WAVE_FORMAT_2S16 | WAVE_FORMAT_4S16))
2061 pCaps->dwFlags |= DSCAPS_PRIMARY16BIT;
2062
2063 pCaps->dwPrimaryBuffers = 1;
2064 TRACE("caps=0x%X\n",(unsigned int)pCaps->dwFlags);
2065 pCaps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
2066 pCaps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
2067
2068 /* the other fields only apply to secondary buffers, which we don't support
2069 * (unless we want to mess with wavetable synthesizers and MIDI) */
2070 return DS_OK;
2071 }
2072
2073 static HRESULT WINAPI IDsDriverImpl_CreateSoundBuffer(PIDSDRIVER iface,
2074 LPWAVEFORMATEX pwfx,
2075 DWORD dwFlags, DWORD dwCardAddress,
2076 LPDWORD pdwcbBufferSize,
2077 LPBYTE *ppbBuffer,
2078 LPVOID *ppvObj)
2079 {
2080 ICOM_THIS(IDsDriverImpl,iface);
2081 IDsDriverBufferImpl** ippdsdb = (IDsDriverBufferImpl**)ppvObj;
2082 int err;
2083
2084 TRACE("(%p,%p,%lx,%lx)\n",iface,pwfx,dwFlags,dwCardAddress);
2085 /* we only support primary buffers */
2086 if (!(dwFlags & DSBCAPS_PRIMARYBUFFER))
2087 return DSERR_UNSUPPORTED;
2088 if (This->primary)
2089 return DSERR_ALLOCATED;
2090 if (dwFlags & (DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN))
2091 return DSERR_CONTROLUNAVAIL;
2092
2093 *ippdsdb = (IDsDriverBufferImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverBufferImpl));
2094 if (*ippdsdb == NULL)
2095 return DSERR_OUTOFMEMORY;
2096 (*ippdsdb)->lpVtbl = &dsdbvt;
2097 (*ippdsdb)->ref = 1;
2098 (*ippdsdb)->drv = This;
2099
2100 err = DSDB_CreateMMAP((*ippdsdb));
2101 if ( err != DS_OK )
2102 {
2103 HeapFree(GetProcessHeap(), 0, *ippdsdb);
2104 *ippdsdb = NULL;
2105 return err;
2106 }
2107 *ppbBuffer = (*ippdsdb)->mmap_buffer;
2108 *pdwcbBufferSize = (*ippdsdb)->mmap_buflen_bytes;
2109
2110 This->primary = *ippdsdb;
2111
2112 /* buffer is ready to go */
2113 TRACE("buffer created at %p\n", *ippdsdb);
2114 return DS_OK;
2115 }
2116
2117 static HRESULT WINAPI IDsDriverImpl_DuplicateSoundBuffer(PIDSDRIVER iface,
2118 PIDSDRIVERBUFFER pBuffer,
2119 LPVOID *ppvObj)
2120 {
2121 /* ICOM_THIS(IDsDriverImpl,iface); */
2122 TRACE("(%p,%p): stub\n",iface,pBuffer);
2123 return DSERR_INVALIDCALL;
2124 }
2125
2126 static ICOM_VTABLE(IDsDriver) dsdvt =
2127 {
2128 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2129 IDsDriverImpl_QueryInterface,
2130 IDsDriverImpl_AddRef,
2131 IDsDriverImpl_Release,
2132 IDsDriverImpl_GetDriverDesc,
2133 IDsDriverImpl_Open,
2134 IDsDriverImpl_Close,
2135 IDsDriverImpl_GetCaps,
2136 IDsDriverImpl_CreateSoundBuffer,
2137 IDsDriverImpl_DuplicateSoundBuffer
2138 };
2139
2140 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
2141 {
2142 IDsDriverImpl** idrv = (IDsDriverImpl**)drv;
2143
2144 TRACE("driver created\n");
2145
2146 /* the HAL isn't much better than the HEL if we can't do mmap() */
2147 if (!(WOutDev[wDevID].caps.dwSupport & WAVECAPS_DIRECTSOUND)) {
2148 ERR("DirectSound flag not set\n");
2149 MESSAGE("This sound card's driver does not support direct access\n");
2150 MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
2151 return MMSYSERR_NOTSUPPORTED;
2152 }
2153
2154 *idrv = (IDsDriverImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDsDriverImpl));
2155 if (!*idrv)
2156 return MMSYSERR_NOMEM;
2157 (*idrv)->lpVtbl = &dsdvt;
2158 (*idrv)->ref = 1;
2159
2160 (*idrv)->wDevID = wDevID;
2161 (*idrv)->primary = NULL;
2162 return MMSYSERR_NOERROR;
2163 }
2164
2165 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
2166 {
2167 memcpy(desc, &(WOutDev[wDevID].ds_desc), sizeof(DSDRIVERDESC));
2168 return MMSYSERR_NOERROR;
2169 }
2170
2171 static DWORD wodDsGuid(UINT wDevID, LPGUID pGuid)
2172 {
2173 TRACE("(%d,%p)\n",wDevID,pGuid);
2174
2175 memcpy(pGuid, &(WOutDev[wDevID].ds_guid), sizeof(GUID));
2176
2177 return MMSYSERR_NOERROR;
2178 }
2179
2180 #endif
2181
2182 #ifndef HAVE_ALSA
2183
2184 /**************************************************************************
2185 * wodMessage (WINEALSA.@)
2186 */
2187 DWORD WINAPI ALSA_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2188 DWORD dwParam1, DWORD dwParam2)
2189 {
2190 FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2191 return MMSYSERR_NOTENABLED;
2192 }
2193
2194 #endif /* HAVE_ALSA */
Maarten's multimedia branch