?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
quartz: Fix string buffer overflow.
[wine.git] / dlls / winmm / tests / wave.c
blob6401fd3fa6f132a95f6442f52543f18e178c15ab
1 /*
2 * Test winmm sound playback in each sound format
3 *
4 * Copyright (c) 2002 Francois Gouget
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <math.h>
25
26 #include "wine/test.h"
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winuser.h"
30 #include "winnls.h"
31 #include "mmsystem.h"
32 #define NOBITMAP
33 #include "mmreg.h"
34 #include "ks.h"
35 #include "ksguid.h"
36 #include "ksmedia.h"
37
38 #include "winmm_test.h"
39
40 /*
41 * Note that in most of this test we may get MMSYSERR_BADDEVICEID errors
42 * at about any time if the user starts another application that uses the
43 * sound device. So we should not report these as test failures.
44 *
45 * This test can play a test tone. But this only makes sense if someone
46 * is going to carefully listen to it, and would only bother everyone else.
47 * So this is only done if the test is being run in interactive mode.
48 */
49
50 #define PI 3.14159265358979323846
51 static char* wave_generate_la(WAVEFORMATEX* wfx, double duration, DWORD* size)
52 {
53 int i,j;
54 int nb_samples;
55 char* buf;
56 char* b;
57 WAVEFORMATEXTENSIBLE *wfex = (WAVEFORMATEXTENSIBLE*)wfx;
58
59 nb_samples=(int)(duration*wfx->nSamplesPerSec);
60 *size=nb_samples*wfx->nBlockAlign;
61 b=buf=HeapAlloc(GetProcessHeap(), 0, *size);
62 for (i=0;i<nb_samples;i++) {
63 double y=sin(440.0*2*PI*i/wfx->nSamplesPerSec);
64 if (wfx->wBitsPerSample==8) {
65 unsigned char sample=(unsigned char)((double)127.5*(y+1.0));
66 for (j = 0; j < wfx->nChannels; j++)
67 *b++=sample;
68 } else if (wfx->wBitsPerSample==16) {
69 signed short sample=(signed short)((double)32767.5*y-0.5);
70 for (j = 0; j < wfx->nChannels; j++) {
71 b[0]=sample & 0xff;
72 b[1]=sample >> 8;
73 b+=2;
74 }
75 } else if (wfx->wBitsPerSample==24) {
76 signed int sample=(signed int)(((double)0x7fffff+0.5)*y-0.5);
77 for (j = 0; j < wfx->nChannels; j++) {
78 b[0]=sample & 0xff;
79 b[1]=(sample >> 8) & 0xff;
80 b[2]=(sample >> 16) & 0xff;
81 b+=3;
82 }
83 } else if ((wfx->wBitsPerSample==32) && ((wfx->wFormatTag == WAVE_FORMAT_PCM) ||
84 ((wfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
85 IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)))) {
86 signed int sample=(signed int)(((double)0x7fffffff+0.5)*y-0.5);
87 for (j = 0; j < wfx->nChannels; j++) {
88 b[0]=sample & 0xff;
89 b[1]=(sample >> 8) & 0xff;
90 b[2]=(sample >> 16) & 0xff;
91 b[3]=(sample >> 24) & 0xff;
92 b+=4;
93 }
94 } else if ((wfx->wBitsPerSample==32) && (wfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
95 IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) {
96 union { float f; char c[4]; } sample;
97 sample.f=(float)y;
98 for (j = 0; j < wfx->nChannels; j++) {
99 b[0]=sample.c[0];
100 b[1]=sample.c[1];
101 b[2]=sample.c[2];
102 b[3]=sample.c[3];
103 b+=4;
104 }
105 }
106 }
107 return buf;
108 }
109
110 static char* wave_generate_silence(WAVEFORMATEX* wfx, double duration, DWORD* size)
111 {
112 int i,j;
113 int nb_samples;
114 char* buf;
115 char* b;
116 WAVEFORMATEXTENSIBLE *wfex = (WAVEFORMATEXTENSIBLE*)wfx;
117
118 nb_samples=(int)(duration*wfx->nSamplesPerSec);
119 *size=nb_samples*wfx->nBlockAlign;
120 b=buf=HeapAlloc(GetProcessHeap(), 0, *size);
121 for (i=0;i<nb_samples;i++) {
122 if (wfx->wBitsPerSample==8) {
123 for (j = 0; j < wfx->nChannels; j++)
124 *b++=128;
125 } else if (wfx->wBitsPerSample==16) {
126 for (j = 0; j < wfx->nChannels; j++) {
127 b[0]=0;
128 b[1]=0;
129 b+=2;
130 }
131 } else if (wfx->wBitsPerSample==24) {
132 for (j = 0; j < wfx->nChannels; j++) {
133 b[0]=0;
134 b[1]=0;
135 b[2]=0;
136 b+=3;
137 }
138 } else if ((wfx->wBitsPerSample==32) && ((wfx->wFormatTag == WAVE_FORMAT_PCM) ||
139 ((wfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
140 IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)))) {
141 for (j = 0; j < wfx->nChannels; j++) {
142 b[0]=0;
143 b[1]=0;
144 b[2]=0;
145 b[3]=0;
146 b+=4;
147 }
148 } else if ((wfx->wBitsPerSample==32) && (wfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
149 IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) {
150 union { float f; char c[4]; } sample;
151 sample.f=0;
152 for (j = 0; j < wfx->nChannels; j++) {
153 b[0]=sample.c[0];
154 b[1]=sample.c[1];
155 b[2]=sample.c[2];
156 b[3]=sample.c[3];
157 b+=4;
158 }
159 }
160 }
161 return buf;
162 }
163
164 const char * dev_name(int device)
165 {
166 static char name[16];
167 if (device == WAVE_MAPPER)
168 return "WAVE_MAPPER";
169 sprintf(name, "%d", device);
170 return name;
171 }
172
173 const char* mmsys_error(MMRESULT error)
174 {
175 #define ERR_TO_STR(dev) case dev: return #dev
176 static char unknown[32];
177 switch (error) {
178 ERR_TO_STR(MMSYSERR_NOERROR);
179 ERR_TO_STR(MMSYSERR_ERROR);
180 ERR_TO_STR(MMSYSERR_BADDEVICEID);
181 ERR_TO_STR(MMSYSERR_NOTENABLED);
182 ERR_TO_STR(MMSYSERR_ALLOCATED);
183 ERR_TO_STR(MMSYSERR_INVALHANDLE);
184 ERR_TO_STR(MMSYSERR_NODRIVER);
185 ERR_TO_STR(MMSYSERR_NOMEM);
186 ERR_TO_STR(MMSYSERR_NOTSUPPORTED);
187 ERR_TO_STR(MMSYSERR_BADERRNUM);
188 ERR_TO_STR(MMSYSERR_INVALFLAG);
189 ERR_TO_STR(MMSYSERR_INVALPARAM);
190 ERR_TO_STR(WAVERR_BADFORMAT);
191 ERR_TO_STR(WAVERR_STILLPLAYING);
192 ERR_TO_STR(WAVERR_UNPREPARED);
193 ERR_TO_STR(WAVERR_SYNC);
194 ERR_TO_STR(MIDIERR_UNPREPARED);
195 ERR_TO_STR(MIDIERR_STILLPLAYING);
196 ERR_TO_STR(MIDIERR_NOTREADY);
197 ERR_TO_STR(MIDIERR_NODEVICE);
198 ERR_TO_STR(MIDIERR_INVALIDSETUP);
199 ERR_TO_STR(TIMERR_NOCANDO);
200 ERR_TO_STR(TIMERR_STRUCT);
201 ERR_TO_STR(JOYERR_PARMS);
202 ERR_TO_STR(JOYERR_NOCANDO);
203 ERR_TO_STR(JOYERR_UNPLUGGED);
204 ERR_TO_STR(MIXERR_INVALLINE);
205 ERR_TO_STR(MIXERR_INVALCONTROL);
206 ERR_TO_STR(MIXERR_INVALVALUE);
207 ERR_TO_STR(MMIOERR_FILENOTFOUND);
208 ERR_TO_STR(MMIOERR_OUTOFMEMORY);
209 ERR_TO_STR(MMIOERR_CANNOTOPEN);
210 ERR_TO_STR(MMIOERR_CANNOTCLOSE);
211 ERR_TO_STR(MMIOERR_CANNOTREAD);
212 ERR_TO_STR(MMIOERR_CANNOTWRITE);
213 ERR_TO_STR(MMIOERR_CANNOTSEEK);
214 ERR_TO_STR(MMIOERR_CANNOTEXPAND);
215 ERR_TO_STR(MMIOERR_CHUNKNOTFOUND);
216 ERR_TO_STR(MMIOERR_UNBUFFERED);
217 }
218 sprintf(unknown, "Unknown(0x%08x)", error);
219 return unknown;
220 #undef ERR_TO_STR
221 }
222
223 const char* wave_out_error(MMRESULT error)
224 {
225 static char msg[1024];
226 static char long_msg[1100];
227 MMRESULT rc;
228
229 rc = waveOutGetErrorText(error, msg, sizeof(msg));
230 if (rc != MMSYSERR_NOERROR)
231 sprintf(long_msg, "waveOutGetErrorText(%x) failed with error %x",
232 error, rc);
233 else
234 sprintf(long_msg, "%s(%s)", mmsys_error(error), msg);
235 return long_msg;
236 }
237
238 const char * wave_open_flags(DWORD flags)
239 {
240 static char msg[1024];
241 int first = TRUE;
242 msg[0] = 0;
243 if ((flags & CALLBACK_TYPEMASK) == CALLBACK_EVENT) {
244 strcat(msg, "CALLBACK_EVENT");
245 first = FALSE;
246 }
247 if ((flags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) {
248 if (!first) strcat(msg, "|");
249 strcat(msg, "CALLBACK_FUNCTION");
250 first = FALSE;
251 }
252 if ((flags & CALLBACK_TYPEMASK) == CALLBACK_NULL) {
253 if (!first) strcat(msg, "|");
254 strcat(msg, "CALLBACK_NULL");
255 first = FALSE;
256 }
257 if ((flags & CALLBACK_TYPEMASK) == CALLBACK_THREAD) {
258 if (!first) strcat(msg, "|");
259 strcat(msg, "CALLBACK_THREAD");
260 first = FALSE;
261 }
262 if ((flags & CALLBACK_TYPEMASK) == CALLBACK_WINDOW) {
263 if (!first) strcat(msg, "|");
264 strcat(msg, "CALLBACK_WINDOW");
265 first = FALSE;
266 }
267 if ((flags & WAVE_ALLOWSYNC) == WAVE_ALLOWSYNC) {
268 if (!first) strcat(msg, "|");
269 strcat(msg, "WAVE_ALLOWSYNC");
270 first = FALSE;
271 }
272 if ((flags & WAVE_FORMAT_DIRECT) == WAVE_FORMAT_DIRECT) {
273 if (!first) strcat(msg, "|");
274 strcat(msg, "WAVE_FORMAT_DIRECT");
275 first = FALSE;
276 }
277 if ((flags & WAVE_FORMAT_QUERY) == WAVE_FORMAT_QUERY) {
278 if (!first) strcat(msg, "|");
279 strcat(msg, "WAVE_FORMAT_QUERY");
280 first = FALSE;
281 }
282 if ((flags & WAVE_MAPPED) == WAVE_MAPPED) {
283 if (!first) strcat(msg, "|");
284 strcat(msg, "WAVE_MAPPED");
285 first = FALSE;
286 }
287 return msg;
288 }
289
290 static const char * wave_header_flags(DWORD flags)
291 {
292 #define WHDR_MASK (WHDR_BEGINLOOP|WHDR_DONE|WHDR_ENDLOOP|WHDR_INQUEUE|WHDR_PREPARED)
293 static char msg[1024];
294 int first = TRUE;
295 msg[0] = 0;
296 if (flags & WHDR_BEGINLOOP) {
297 strcat(msg, "WHDR_BEGINLOOP");
298 first = FALSE;
299 }
300 if (flags & WHDR_DONE) {
301 if (!first) strcat(msg, " ");
302 strcat(msg, "WHDR_DONE");
303 first = FALSE;
304 }
305 if (flags & WHDR_ENDLOOP) {
306 if (!first) strcat(msg, " ");
307 strcat(msg, "WHDR_ENDLOOP");
308 first = FALSE;
309 }
310 if (flags & WHDR_INQUEUE) {
311 if (!first) strcat(msg, " ");
312 strcat(msg, "WHDR_INQUEUE");
313 first = FALSE;
314 }
315 if (flags & WHDR_PREPARED) {
316 if (!first) strcat(msg, " ");
317 strcat(msg, "WHDR_PREPARED");
318 first = FALSE;
319 }
320 if (flags & ~WHDR_MASK) {
321 char temp[32];
322 sprintf(temp, "UNKNOWN(0x%08x)", flags & ~WHDR_MASK);
323 if (!first) strcat(msg, " ");
324 strcat(msg, temp);
325 }
326 return msg;
327 }
328
329 static const char * wave_out_caps(DWORD dwSupport)
330 {
331 #define ADD_FLAG(f) if (dwSupport & f) strcat(msg, " " #f)
332 static char msg[256];
333 msg[0] = 0;
334
335 ADD_FLAG(WAVECAPS_PITCH);
336 ADD_FLAG(WAVECAPS_PLAYBACKRATE);
337 ADD_FLAG(WAVECAPS_VOLUME);
338 ADD_FLAG(WAVECAPS_LRVOLUME);
339 ADD_FLAG(WAVECAPS_SYNC);
340 ADD_FLAG(WAVECAPS_SAMPLEACCURATE);
341
342 return msg[0] ? msg + 1 : "";
343 #undef ADD_FLAG
344 }
345
346 const char * wave_time_format(UINT type)
347 {
348 static char msg[32];
349 #define TIME_FORMAT(f) case f: return #f
350 switch (type) {
351 TIME_FORMAT(TIME_MS);
352 TIME_FORMAT(TIME_SAMPLES);
353 TIME_FORMAT(TIME_BYTES);
354 TIME_FORMAT(TIME_SMPTE);
355 TIME_FORMAT(TIME_MIDI);
356 TIME_FORMAT(TIME_TICKS);
357 }
358 #undef TIME_FORMAT
359 sprintf(msg, "Unknown(0x%04x)", type);
360 return msg;
361 }
362
363 const char * get_format_str(WORD format)
364 {
365 static char msg[32];
366 #define WAVE_FORMAT(f) case f: return #f
367 switch (format) {
368 WAVE_FORMAT(WAVE_FORMAT_PCM);
369 WAVE_FORMAT(WAVE_FORMAT_ADPCM);
370 WAVE_FORMAT(WAVE_FORMAT_IBM_CVSD);
371 WAVE_FORMAT(WAVE_FORMAT_ALAW);
372 WAVE_FORMAT(WAVE_FORMAT_MULAW);
373 WAVE_FORMAT(WAVE_FORMAT_OKI_ADPCM);
374 WAVE_FORMAT(WAVE_FORMAT_IMA_ADPCM);
375 WAVE_FORMAT(WAVE_FORMAT_MEDIASPACE_ADPCM);
376 WAVE_FORMAT(WAVE_FORMAT_SIERRA_ADPCM);
377 WAVE_FORMAT(WAVE_FORMAT_G723_ADPCM);
378 WAVE_FORMAT(WAVE_FORMAT_DIGISTD);
379 WAVE_FORMAT(WAVE_FORMAT_DIGIFIX);
380 WAVE_FORMAT(WAVE_FORMAT_DIALOGIC_OKI_ADPCM);
381 WAVE_FORMAT(WAVE_FORMAT_YAMAHA_ADPCM);
382 WAVE_FORMAT(WAVE_FORMAT_SONARC);
383 WAVE_FORMAT(WAVE_FORMAT_DSPGROUP_TRUESPEECH);
384 WAVE_FORMAT(WAVE_FORMAT_ECHOSC1);
385 WAVE_FORMAT(WAVE_FORMAT_AUDIOFILE_AF36);
386 WAVE_FORMAT(WAVE_FORMAT_APTX);
387 WAVE_FORMAT(WAVE_FORMAT_AUDIOFILE_AF10);
388 WAVE_FORMAT(WAVE_FORMAT_DOLBY_AC2);
389 WAVE_FORMAT(WAVE_FORMAT_GSM610);
390 WAVE_FORMAT(WAVE_FORMAT_ANTEX_ADPCME);
391 WAVE_FORMAT(WAVE_FORMAT_CONTROL_RES_VQLPC);
392 WAVE_FORMAT(WAVE_FORMAT_DIGIREAL);
393 WAVE_FORMAT(WAVE_FORMAT_DIGIADPCM);
394 WAVE_FORMAT(WAVE_FORMAT_CONTROL_RES_CR10);
395 WAVE_FORMAT(WAVE_FORMAT_NMS_VBXADPCM);
396 WAVE_FORMAT(WAVE_FORMAT_G721_ADPCM);
397 WAVE_FORMAT(WAVE_FORMAT_MPEG);
398 WAVE_FORMAT(WAVE_FORMAT_MPEGLAYER3);
399 WAVE_FORMAT(WAVE_FORMAT_CREATIVE_ADPCM);
400 WAVE_FORMAT(WAVE_FORMAT_CREATIVE_FASTSPEECH8);
401 WAVE_FORMAT(WAVE_FORMAT_CREATIVE_FASTSPEECH10);
402 WAVE_FORMAT(WAVE_FORMAT_FM_TOWNS_SND);
403 WAVE_FORMAT(WAVE_FORMAT_OLIGSM);
404 WAVE_FORMAT(WAVE_FORMAT_OLIADPCM);
405 WAVE_FORMAT(WAVE_FORMAT_OLICELP);
406 WAVE_FORMAT(WAVE_FORMAT_OLISBC);
407 WAVE_FORMAT(WAVE_FORMAT_OLIOPR);
408 WAVE_FORMAT(WAVE_FORMAT_DEVELOPMENT);
409 WAVE_FORMAT(WAVE_FORMAT_EXTENSIBLE);
410 }
411 #undef WAVE_FORMAT
412 sprintf(msg, "Unknown(0x%04x)", format);
413 return msg;
414 }
415
416 DWORD bytes_to_samples(DWORD bytes, LPWAVEFORMATEX pwfx)
417 {
418 return bytes / pwfx->nBlockAlign;
419 }
420
421 DWORD bytes_to_ms(DWORD bytes, LPWAVEFORMATEX pwfx)
422 {
423 return bytes_to_samples(bytes, pwfx) * 1000 / pwfx->nSamplesPerSec;
424 }
425
426 DWORD time_to_bytes(LPMMTIME mmtime, LPWAVEFORMATEX pwfx)
427 {
428 if (mmtime->wType == TIME_BYTES)
429 return mmtime->u.cb;
430 else if (mmtime->wType == TIME_SAMPLES)
431 return mmtime->u.sample * pwfx->nBlockAlign;
432 else if (mmtime->wType == TIME_MS)
433 return mmtime->u.ms * pwfx->nAvgBytesPerSec / 1000;
434 else if (mmtime->wType == TIME_SMPTE)
435 return ((mmtime->u.smpte.hour * 60.0 * 60.0) +
436 (mmtime->u.smpte.min * 60.0) +
437 (mmtime->u.smpte.sec) +
438 (mmtime->u.smpte.frame / 30.0)) * pwfx->nAvgBytesPerSec;
439
440 trace("FIXME: time_to_bytes() type not supported\n");
441 return -1;
442 }
443
444 static void check_position(int device, HWAVEOUT wout, DWORD bytes,
445 LPWAVEFORMATEX pwfx )
446 {
447 MMTIME mmtime;
448 DWORD samples;
449 double duration;
450 MMRESULT rc;
451 DWORD returned;
452
453 samples=bytes/(pwfx->wBitsPerSample/8*pwfx->nChannels);
454 duration=((double)samples)/pwfx->nSamplesPerSec;
455
456 mmtime.wType = TIME_BYTES;
457 rc=waveOutGetPosition(wout, &mmtime, sizeof(mmtime));
458 ok(rc==MMSYSERR_NOERROR,
459 "waveOutGetPosition(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
460 if (mmtime.wType != TIME_BYTES && winetest_debug > 1)
461 trace("waveOutGetPosition(%s): TIME_BYTES not supported, returned %s\n",
462 dev_name(device),wave_time_format(mmtime.wType));
463 returned = time_to_bytes(&mmtime, pwfx);
464 ok(returned == bytes, "waveOutGetPosition(%s): returned %d bytes, "
465 "should be %d\n", dev_name(device), returned, bytes);
466
467 mmtime.wType = TIME_SAMPLES;
468 rc=waveOutGetPosition(wout, &mmtime, sizeof(mmtime));
469 ok(rc==MMSYSERR_NOERROR,
470 "waveOutGetPosition(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
471 if (mmtime.wType != TIME_SAMPLES && winetest_debug > 1)
472 trace("waveOutGetPosition(%s): TIME_SAMPLES not supported, "
473 "returned %s\n",dev_name(device),wave_time_format(mmtime.wType));
474 returned = time_to_bytes(&mmtime, pwfx);
475 ok(returned == bytes, "waveOutGetPosition(%s): returned %d samples "
476 "(%d bytes), should be %d (%d bytes)\n", dev_name(device),
477 bytes_to_samples(returned, pwfx), returned,
478 bytes_to_samples(bytes, pwfx), bytes);
479
480 mmtime.wType = TIME_MS;
481 rc=waveOutGetPosition(wout, &mmtime, sizeof(mmtime));
482 ok(rc==MMSYSERR_NOERROR,
483 "waveOutGetPosition(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
484 if (mmtime.wType != TIME_MS && winetest_debug > 1)
485 trace("waveOutGetPosition(%s): TIME_MS not supported, returned %s\n",
486 dev_name(device), wave_time_format(mmtime.wType));
487 returned = time_to_bytes(&mmtime, pwfx);
488 ok(returned == bytes, "waveOutGetPosition(%s): returned %d ms, "
489 "(%d bytes), should be %d (%d bytes)\n", dev_name(device),
490 bytes_to_ms(returned, pwfx), returned,
491 bytes_to_ms(bytes, pwfx), bytes);
492
493 mmtime.wType = TIME_SMPTE;
494 rc=waveOutGetPosition(wout, &mmtime, sizeof(mmtime));
495 ok(rc==MMSYSERR_NOERROR,
496 "waveOutGetPosition(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
497 if (mmtime.wType != TIME_SMPTE && winetest_debug > 1)
498 trace("waveOutGetPosition(%s): TIME_SMPTE not supported, returned %s\n",
499 dev_name(device),wave_time_format(mmtime.wType));
500 returned = time_to_bytes(&mmtime, pwfx);
501 ok(returned == bytes, "waveOutGetPosition(%s): SMPTE test failed\n",
502 dev_name(device));
503
504 mmtime.wType = TIME_MIDI;
505 rc=waveOutGetPosition(wout, &mmtime, sizeof(mmtime));
506 ok(rc==MMSYSERR_NOERROR,
507 "waveOutGetPosition(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
508 if (mmtime.wType != TIME_MIDI && winetest_debug > 1)
509 trace("waveOutGetPosition(%s): TIME_MIDI not supported, returned %s\n",
510 dev_name(device),wave_time_format(mmtime.wType));
511 returned = time_to_bytes(&mmtime, pwfx);
512 ok(returned == bytes, "waveOutGetPosition(%s): MIDI test failed\n",
513 dev_name(device));
514
515 mmtime.wType = TIME_TICKS;
516 rc=waveOutGetPosition(wout, &mmtime, sizeof(mmtime));
517 ok(rc==MMSYSERR_NOERROR,
518 "waveOutGetPosition(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
519 if (mmtime.wType != TIME_TICKS && winetest_debug > 1)
520 trace("waveOutGetPosition(%s): TIME_TICKS not supported, returned %s\n",
521 dev_name(device),wave_time_format(mmtime.wType));
522 returned = time_to_bytes(&mmtime, pwfx);
523 ok(returned == bytes, "waveOutGetPosition(%s): TICKS test failed\n",
524 dev_name(device));
525 }
526
527 static void CALLBACK callback_func(HWAVEOUT hwo, UINT uMsg,
528 DWORD_PTR dwInstance,
529 DWORD dwParam1, DWORD dwParam2)
530 {
531 SetEvent((HANDLE)dwInstance);
532 }
533
534 static DWORD WINAPI callback_thread(LPVOID lpParameter)
535 {
536 MSG msg;
537
538 PeekMessageW( &msg, 0, 0, 0, PM_NOREMOVE ); /* make sure the thread has a message queue */
539 SetEvent((HANDLE)lpParameter);
540
541 while (GetMessage(&msg, 0, 0, 0)) {
542 UINT message = msg.message;
543 /* for some reason XP sends a WM_USER message before WOM_OPEN */
544 ok (message == WOM_OPEN || message == WOM_DONE ||
545 message == WOM_CLOSE || message == WM_USER || message == WM_APP,
546 "GetMessage returned unexpected message: %u\n", message);
547 if (message == WOM_OPEN || message == WOM_DONE || message == WOM_CLOSE)
548 SetEvent((HANDLE)lpParameter);
549 else if (message == WM_APP) {
550 SetEvent((HANDLE)lpParameter);
551 return 0;
552 }
553 }
554
555 return 0;
556 }
557
558 static void wave_out_test_deviceOut(int device, double duration,
559 int headers, int loops,
560 LPWAVEFORMATEX pwfx, DWORD format,
561 DWORD flags, LPWAVEOUTCAPS pcaps,
562 BOOL interactive, BOOL sine, BOOL pause)
563 {
564 HWAVEOUT wout;
565 HANDLE hevent;
566 WAVEHDR *frags = 0;
567 MMRESULT rc;
568 DWORD volume;
569 WORD nChannels = pwfx->nChannels;
570 WORD wBitsPerSample = pwfx->wBitsPerSample;
571 DWORD nSamplesPerSec = pwfx->nSamplesPerSec;
572 BOOL has_volume = pcaps->dwSupport & WAVECAPS_VOLUME ? TRUE : FALSE;
573 double paused = 0.0;
574 double actual;
575 DWORD callback = 0;
576 DWORD callback_instance = 0;
577 HANDLE thread = 0;
578 DWORD thread_id;
579 char * buffer;
580 DWORD length;
581 DWORD frag_length;
582 int i, j;
583
584 hevent=CreateEvent(NULL,FALSE,FALSE,NULL);
585 ok(hevent!=NULL,"CreateEvent(): error=%d\n",GetLastError());
586 if (hevent==NULL)
587 return;
588
589 if ((flags & CALLBACK_TYPEMASK) == CALLBACK_EVENT) {
590 callback = (DWORD)hevent;
591 callback_instance = 0;
592 } else if ((flags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) {
593 callback = (DWORD)callback_func;
594 callback_instance = (DWORD)hevent;
595 } else if ((flags & CALLBACK_TYPEMASK) == CALLBACK_THREAD) {
596 thread = CreateThread(NULL, 0, callback_thread, hevent, 0, &thread_id);
597 if (thread) {
598 /* make sure thread is running */
599 WaitForSingleObject(hevent,INFINITE);
600 callback = thread_id;
601 callback_instance = 0;
602 } else {
603 trace("CreateThread() failed\n");
604 CloseHandle(hevent);
605 return;
606 }
607 } else if ((flags & CALLBACK_TYPEMASK) == CALLBACK_WINDOW) {
608 trace("CALLBACK_THREAD not implemented\n");
609 CloseHandle(hevent);
610 return;
611 } else if (flags && CALLBACK_TYPEMASK) {
612 trace("Undefined callback type!\n");
613 CloseHandle(hevent);
614 return;
615 } else {
616 trace("CALLBACK_NULL not implemented\n");
617 CloseHandle(hevent);
618 return;
619 }
620 wout=NULL;
621 rc=waveOutOpen(&wout,device,pwfx,callback,callback_instance,flags);
622 /* Note: Win9x doesn't know WAVE_FORMAT_DIRECT */
623 /* It is acceptable to fail on formats that are not specified to work */
624 ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID ||
625 rc==MMSYSERR_NOTENABLED || rc==MMSYSERR_NODRIVER ||
626 rc==MMSYSERR_ALLOCATED ||
627 ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
628 (flags & WAVE_FORMAT_DIRECT) && !(pcaps->dwFormats & format)) ||
629 ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
630 (!(flags & WAVE_FORMAT_DIRECT) || (flags & WAVE_MAPPED)) &&
631 !(pcaps->dwFormats & format)) ||
632 (rc==MMSYSERR_INVALFLAG && (flags & WAVE_FORMAT_DIRECT)),
633 "waveOutOpen(%s): format=%dx%2dx%d flags=%lx(%s) rc=%s\n",
634 dev_name(device),pwfx->nSamplesPerSec,pwfx->wBitsPerSample,
635 pwfx->nChannels,CALLBACK_EVENT|flags,
636 wave_open_flags(CALLBACK_EVENT|flags),wave_out_error(rc));
637 if ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
638 (flags & WAVE_FORMAT_DIRECT) && (pcaps->dwFormats & format))
639 trace(" Reason: The device lists this format as supported in it's "
640 "capabilities but opening it failed.\n");
641 if ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) &&
642 !(pcaps->dwFormats & format))
643 trace("waveOutOpen(%s): format=%dx%2dx%d %s rc=%s failed but format "
644 "not supported so OK.\n", dev_name(device), pwfx->nSamplesPerSec,
645 pwfx->wBitsPerSample,pwfx->nChannels,
646 flags & WAVE_FORMAT_DIRECT ? "flags=WAVE_FORMAT_DIRECT" :
647 flags & WAVE_MAPPED ? "flags=WAVE_MAPPED" : "", mmsys_error(rc));
648 if (rc!=MMSYSERR_NOERROR)
649 goto EXIT;
650
651 WaitForSingleObject(hevent,INFINITE);
652
653 ok(pwfx->nChannels==nChannels &&
654 pwfx->wBitsPerSample==wBitsPerSample &&
655 pwfx->nSamplesPerSec==nSamplesPerSec,
656 "got the wrong format: %dx%2dx%d instead of %dx%2dx%d\n",
657 pwfx->nSamplesPerSec, pwfx->wBitsPerSample,
658 pwfx->nChannels, nSamplesPerSec, wBitsPerSample, nChannels);
659
660 frags = HeapAlloc(GetProcessHeap(), 0, headers * sizeof(WAVEHDR));
661
662 if (sine)
663 buffer=wave_generate_la(pwfx,duration / (loops + 1),&length);
664 else
665 buffer=wave_generate_silence(pwfx,duration / (loops + 1),&length);
666
667 rc=waveOutGetVolume(wout,0);
668 ok(rc==MMSYSERR_INVALPARAM,"waveOutGetVolume(%s,0) expected "
669 "MMSYSERR_INVALPARAM, got %s\n", dev_name(device),wave_out_error(rc));
670 rc=waveOutGetVolume(wout,&volume);
671 ok(has_volume ? rc==MMSYSERR_NOERROR : rc==MMSYSERR_NOTSUPPORTED,
672 "waveOutGetVolume(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
673
674 /* make sure fragment length is a multiple of block size */
675 frag_length = ((length / headers) / pwfx->nBlockAlign) * pwfx->nBlockAlign;
676
677 for (i = 0; i < headers; i++) {
678 frags[i].lpData=buffer + (i * frag_length);
679 if (i != (headers-1))
680 frags[i].dwBufferLength=frag_length;
681 else {
682 /* use remainder of buffer for last fragment */
683 frags[i].dwBufferLength=length - (i * frag_length);
684 }
685 frags[i].dwFlags=0;
686 frags[i].dwLoops=0;
687 rc=waveOutPrepareHeader(wout, &frags[i], sizeof(frags[0]));
688 ok(rc==MMSYSERR_NOERROR,
689 "waveOutPrepareHeader(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
690 }
691
692 if (interactive && rc==MMSYSERR_NOERROR) {
693 DWORD start,end;
694 trace("Playing %g second %s at %5dx%2dx%d %2d header%s %d loop%s %d bytes %s %s\n",duration,
695 sine ? "440Hz tone" : "silence",pwfx->nSamplesPerSec,
696 pwfx->wBitsPerSample,pwfx->nChannels, headers, headers > 1 ? "s": " ",
697 loops, loops == 1 ? " " : "s", length * (loops + 1),
698 get_format_str(pwfx->wFormatTag),
699 wave_open_flags(flags));
700 if (sine && has_volume && volume == 0)
701 trace("*** Warning the sound is muted, you will not hear the test\n");
702
703 /* Check that the position is 0 at start */
704 check_position(device, wout, 0, pwfx);
705
706 rc=waveOutSetVolume(wout,0x20002000);
707 ok(has_volume ? rc==MMSYSERR_NOERROR : rc==MMSYSERR_NOTSUPPORTED,
708 "waveOutSetVolume(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
709
710 rc=waveOutSetVolume(wout,volume);
711 ok(has_volume ? rc==MMSYSERR_NOERROR : rc==MMSYSERR_NOTSUPPORTED,
712 "waveOutSetVolume(%s): rc=%s\n",dev_name(device),wave_out_error(rc));
713
714 start=GetTickCount();
715
716 rc=waveOutWrite(wout, &frags[0], sizeof(frags[0]));
717 ok(rc==MMSYSERR_NOERROR,"waveOutWrite(%s): rc=%s\n",
718 dev_name(device),wave_out_error(rc));
719
720 ok(frags[0].dwFlags==(WHDR_PREPARED|WHDR_INQUEUE),
721 "WHDR_INQUEUE WHDR_PREPARED expected, got= %s\n",
722 wave_header_flags(frags[0].dwFlags));
723
724 rc=waveOutWrite(wout, &frags[0], sizeof(frags[0]));
725 ok(rc==WAVERR_STILLPLAYING,
726 "waveOutWrite(%s): WAVE_STILLPLAYING expected, got %s\n",
727 dev_name(device),wave_out_error(rc));
728
729 ok(frags[0].dwFlags==(WHDR_PREPARED|WHDR_INQUEUE),
730 "WHDR_INQUEUE WHDR_PREPARED expected, got %s\n",
731 wave_header_flags(frags[0].dwFlags));
732
733 if (headers == 1 && loops == 0 && pause) {
734 paused = duration / 2;
735 Sleep(paused * 1000);
736 rc=waveOutPause(wout);
737 ok(rc==MMSYSERR_NOERROR,"waveOutPause(%s): rc=%s\n",
738 dev_name(device),wave_out_error(rc));
739 trace("pausing for %g seconds\n", paused);
740 Sleep(paused * 1000);
741 rc=waveOutRestart(wout);
742 ok(rc==MMSYSERR_NOERROR,"waveOutRestart(%s): rc=%s\n",
743 dev_name(device),wave_out_error(rc));
744 }
745
746 for (j = 0; j <= loops; j++) {
747 for (i = 0; i < headers; i++) {
748 /* don't do last one */
749 if (!((j == loops) && (i == (headers - 1)))) {
750 if (j > 0)
751 frags[(i+1) % headers].dwFlags = WHDR_PREPARED;
752 rc=waveOutWrite(wout, &frags[(i+1) % headers], sizeof(frags[0]));
753 ok(rc==MMSYSERR_NOERROR,"waveOutWrite(%s, header[%d]): rc=%s\n",
754 dev_name(device),(i+1)%headers,wave_out_error(rc));
755 }
756 WaitForSingleObject(hevent,INFINITE);
757 }
758 }
759
760 /* Check the sound duration was between -2% and +10% of the expected value */
761 end=GetTickCount();
762 actual = (end - start) / 1000.0;
763 if (winetest_debug > 1)
764 trace("sound duration=%g ms\n",1000*actual);
765 ok((actual > (0.97 * (duration+paused))) &&
766 (actual < (1.1 * (duration+paused))),
767 "The sound played for %g ms instead of %g ms\n",
768 1000*actual,1000*(duration+paused));
769 for (i = 0; i < headers; i++) {
770 ok(frags[i].dwFlags=(WHDR_DONE|WHDR_PREPARED),
771 "WHDR_DONE WHDR_PREPARED expected, got %s\n",
772 wave_header_flags(frags[i].dwFlags));
773 }
774 check_position(device, wout, length * (loops + 1), pwfx);
775 }
776
777 for (i = 0; i < headers; i++) {
778 rc=waveOutUnprepareHeader(wout, &frags[i], sizeof(frags[0]));
779 ok(rc==MMSYSERR_NOERROR,
780 "waveOutUnprepareHeader(%s): rc=%s\n",dev_name(device),
781 wave_out_error(rc));
782 }
783 HeapFree(GetProcessHeap(), 0, buffer);
784
785 rc=waveOutClose(wout);
786 ok(rc==MMSYSERR_NOERROR,"waveOutClose(%s): rc=%s\n",dev_name(device),
787 wave_out_error(rc));
788 WaitForSingleObject(hevent,INFINITE);
789 EXIT:
790 if ((flags & CALLBACK_TYPEMASK) == CALLBACK_THREAD) {
791 PostThreadMessage(thread_id, WM_APP, 0, 0);
792 WaitForSingleObject(hevent,INFINITE);
793 }
794 CloseHandle(hevent);
795 HeapFree(GetProcessHeap(), 0, frags);
796 }
797
798 static void wave_out_test_device(int device)
799 {
800 WAVEOUTCAPSA capsA;
801 WAVEOUTCAPSW capsW;
802 WAVEFORMATEX format, oformat;
803 WAVEFORMATEXTENSIBLE wfex;
804 HWAVEOUT wout;
805 MMRESULT rc;
806 UINT f;
807 WCHAR * nameW;
808 CHAR * nameA;
809 DWORD size;
810 DWORD dwPageSize;
811 BYTE * twoPages;
812 SYSTEM_INFO sSysInfo;
813 DWORD flOldProtect;
814 BOOL res;
815
816 GetSystemInfo(&sSysInfo);
817 dwPageSize = sSysInfo.dwPageSize;
818
819 rc=waveOutGetDevCapsA(device,&capsA,sizeof(capsA));
820 ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID ||
821 rc==MMSYSERR_NODRIVER,
822 "waveOutGetDevCapsA(%s): failed to get capabilities: rc=%s\n",
823 dev_name(device),wave_out_error(rc));
824 if (rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NODRIVER)
825 return;
826
827 rc=waveOutGetDevCapsW(device,&capsW,sizeof(capsW));
828 ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NOTSUPPORTED,
829 "waveOutGetDevCapsW(%s): MMSYSERR_NOERROR or MMSYSERR_NOTSUPPORTED "
830 "expected, got %s\n",dev_name(device),wave_out_error(rc));
831
832 rc=waveOutGetDevCapsA(device,0,sizeof(capsA));
833 ok(rc==MMSYSERR_INVALPARAM,
834 "waveOutGetDevCapsA(%s): MMSYSERR_INVALPARAM expected, "
835 "got %s\n",dev_name(device),wave_out_error(rc));
836
837 rc=waveOutGetDevCapsW(device,0,sizeof(capsW));
838 ok(rc==MMSYSERR_INVALPARAM || rc==MMSYSERR_NOTSUPPORTED,
839 "waveOutGetDevCapsW(%s): MMSYSERR_INVALPARAM or MMSYSERR_NOTSUPPORTED "
840 "expected, got %s\n",dev_name(device),wave_out_error(rc));
841
842 if (0)
843 {
844 /* FIXME: this works on windows but crashes wine */
845 rc=waveOutGetDevCapsA(device,(LPWAVEOUTCAPSA)1,sizeof(capsA));
846 ok(rc==MMSYSERR_INVALPARAM,
847 "waveOutGetDevCapsA(%s): MMSYSERR_INVALPARAM expected, got %s\n",
848 dev_name(device),wave_out_error(rc));
849
850 rc=waveOutGetDevCapsW(device,(LPWAVEOUTCAPSW)1,sizeof(capsW));
851 ok(rc==MMSYSERR_INVALPARAM || rc==MMSYSERR_NOTSUPPORTED,
852 "waveOutGetDevCapsW(%s): MMSYSERR_INVALPARAM or MMSYSERR_NOTSUPPORTED "
853 "expected, got %s\n",dev_name(device),wave_out_error(rc));
854 }
855
856 rc=waveOutGetDevCapsA(device,&capsA,4);
857 ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_INVALPARAM,
858 "waveOutGetDevCapsA(%s): MMSYSERR_NOERROR or MMSYSERR_INVALPARAM "
859 "expected, got %s\n", dev_name(device),wave_out_error(rc));
860
861 rc=waveOutGetDevCapsW(device,&capsW,4);
862 ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NOTSUPPORTED,
863 "waveOutGetDevCapsW(%s): MMSYSERR_NOERROR or MMSYSERR_NOTSUPPORTED "
864 "expected, got %s\n",dev_name(device),wave_out_error(rc));
865
866 nameA=NULL;
867 rc=waveOutMessage((HWAVEOUT)device, DRV_QUERYDEVICEINTERFACESIZE,
868 (DWORD_PTR)&size, 0);
869 ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_INVALPARAM ||
870 rc==MMSYSERR_NOTSUPPORTED,
871 "waveOutMessage(%s): failed to get interface size, rc=%s\n",
872 dev_name(device),wave_out_error(rc));
873 if (rc==MMSYSERR_NOERROR) {
874 nameW = HeapAlloc(GetProcessHeap(), 0, size);
875 rc=waveOutMessage((HWAVEOUT)device, DRV_QUERYDEVICEINTERFACE,
876 (DWORD_PTR)nameW, size);
877 ok(rc==MMSYSERR_NOERROR,"waveOutMessage(%s): failed to get interface "
878 "name, rc=%s\n",dev_name(device),wave_out_error(rc));
879 ok(lstrlenW(nameW)+1==size/sizeof(WCHAR),"got an incorrect size %d\n",size);
880 if (rc==MMSYSERR_NOERROR) {
881 nameA = HeapAlloc(GetProcessHeap(), 0, size/sizeof(WCHAR));
882 WideCharToMultiByte(CP_ACP, 0, nameW, size/sizeof(WCHAR), nameA,
883 size/sizeof(WCHAR), NULL, NULL);
884 }
885 HeapFree(GetProcessHeap(), 0, nameW);
886 }
887 else if (rc==MMSYSERR_NOTSUPPORTED) {
888 nameA=HeapAlloc(GetProcessHeap(), 0, sizeof("not supported"));
889 strcpy(nameA, "not supported");
890 }
891
892 rc=waveOutGetDevCapsA(device,&capsA,sizeof(capsA));
893 ok(rc==MMSYSERR_NOERROR,
894 "waveOutGetDevCapsA(%s): MMSYSERR_NOERROR expected, got %s\n",
895 dev_name(device),wave_out_error(rc));
896 if (rc!=MMSYSERR_NOERROR)
897 return;
898
899 trace(" %s: \"%s\" (%s) %d.%d (%d:%d)\n",dev_name(device),capsA.szPname,
900 (nameA?nameA:"failed"),capsA.vDriverVersion >> 8,
901 capsA.vDriverVersion & 0xff, capsA.wMid,capsA.wPid);
902 trace(" channels=%d formats=%05x support=%04x\n",
903 capsA.wChannels,capsA.dwFormats,capsA.dwSupport);
904 trace(" %s\n",wave_out_caps(capsA.dwSupport));
905 HeapFree(GetProcessHeap(), 0, nameA);
906
907 if (winetest_interactive && (device != WAVE_MAPPER))
908 {
909 trace("Playing a 5 seconds reference tone.\n");
910 trace("All subsequent tones should be identical to this one.\n");
911 trace("Listen for stutter, changes in pitch, volume, etc.\n");
912 format.wFormatTag=WAVE_FORMAT_PCM;
913 format.nChannels=1;
914 format.wBitsPerSample=8;
915 format.nSamplesPerSec=22050;
916 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
917 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
918 format.cbSize=0;
919
920 wave_out_test_deviceOut(device,5.0,1,0,&format,WAVE_FORMAT_2M08,
921 CALLBACK_EVENT,&capsA,TRUE,TRUE,FALSE);
922 wave_out_test_deviceOut(device,5.0,1,0,&format,WAVE_FORMAT_2M08,
923 CALLBACK_FUNCTION,&capsA,TRUE,TRUE,FALSE);
924 wave_out_test_deviceOut(device,5.0,1,0,&format,WAVE_FORMAT_2M08,
925 CALLBACK_THREAD,&capsA,TRUE,TRUE,FALSE);
926
927 wave_out_test_deviceOut(device,5.0,10,0,&format,WAVE_FORMAT_2M08,
928 CALLBACK_EVENT,&capsA,TRUE,TRUE,FALSE);
929 wave_out_test_deviceOut(device,5.0,5,1,&format,WAVE_FORMAT_2M08,
930 CALLBACK_EVENT,&capsA,TRUE,TRUE,FALSE);
931 } else {
932 format.wFormatTag=WAVE_FORMAT_PCM;
933 format.nChannels=1;
934 format.wBitsPerSample=8;
935 format.nSamplesPerSec=22050;
936 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
937 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
938 format.cbSize=0;
939 wave_out_test_deviceOut(device,1.0,1,0,&format,WAVE_FORMAT_2M08,
940 CALLBACK_EVENT,&capsA,TRUE,FALSE,FALSE);
941 wave_out_test_deviceOut(device,1.0,1,0,&format,WAVE_FORMAT_2M08,
942 CALLBACK_EVENT,&capsA,TRUE,FALSE,TRUE);
943 wave_out_test_deviceOut(device,1.0,1,0,&format,WAVE_FORMAT_2M08,
944 CALLBACK_FUNCTION,&capsA,TRUE,FALSE,FALSE);
945 wave_out_test_deviceOut(device,1.0,1,0,&format,WAVE_FORMAT_2M08,
946 CALLBACK_FUNCTION,&capsA,TRUE,FALSE,TRUE);
947 wave_out_test_deviceOut(device,1.0,1,0,&format,WAVE_FORMAT_2M08,
948 CALLBACK_THREAD,&capsA,TRUE,FALSE,FALSE);
949 wave_out_test_deviceOut(device,1.0,1,0,&format,WAVE_FORMAT_2M08,
950 CALLBACK_THREAD,&capsA,TRUE,FALSE,TRUE);
951
952 wave_out_test_deviceOut(device,1.0,10,0,&format,WAVE_FORMAT_2M08,
953 CALLBACK_EVENT,&capsA,TRUE,FALSE,FALSE);
954 wave_out_test_deviceOut(device,1.0,5,1,&format,WAVE_FORMAT_2M08,
955 CALLBACK_EVENT,&capsA,TRUE,FALSE,FALSE);
956 }
957
958 for (f=0;f<NB_WIN_FORMATS;f++) {
959 format.wFormatTag=WAVE_FORMAT_PCM;
960 format.nChannels=win_formats[f][3];
961 format.wBitsPerSample=win_formats[f][2];
962 format.nSamplesPerSec=win_formats[f][1];
963 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
964 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
965 format.cbSize=0;
966 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
967 CALLBACK_EVENT,&capsA,winetest_interactive,
968 TRUE,FALSE);
969 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
970 CALLBACK_FUNCTION,&capsA,winetest_interactive,
971 TRUE,FALSE);
972 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
973 CALLBACK_THREAD,&capsA,winetest_interactive,
974 TRUE,FALSE);
975
976 wave_out_test_deviceOut(device,1.0,10,0,&format,win_formats[f][0],
977 CALLBACK_EVENT,&capsA,winetest_interactive,
978 TRUE,FALSE);
979 wave_out_test_deviceOut(device,1.0,5,1,&format,win_formats[f][0],
980 CALLBACK_EVENT,&capsA,winetest_interactive,
981 TRUE,FALSE);
982
983 if (winetest_interactive) {
984 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
985 CALLBACK_EVENT,&capsA,winetest_interactive,
986 TRUE,TRUE);
987 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
988 CALLBACK_FUNCTION,&capsA,winetest_interactive,
989 TRUE,TRUE);
990 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
991 CALLBACK_THREAD,&capsA,winetest_interactive,
992 TRUE,TRUE);
993
994 wave_out_test_deviceOut(device,1.0,10,0,&format,win_formats[f][0],
995 CALLBACK_EVENT,&capsA,winetest_interactive,
996 TRUE,TRUE);
997 wave_out_test_deviceOut(device,1.0,5,1,&format,win_formats[f][0],
998 CALLBACK_EVENT,&capsA,winetest_interactive,
999 TRUE,TRUE);
1000 }
1001 if (device != WAVE_MAPPER)
1002 {
1003 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
1004 CALLBACK_EVENT|WAVE_FORMAT_DIRECT,&capsA,
1005 winetest_interactive,TRUE,FALSE);
1006 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
1007 CALLBACK_EVENT|WAVE_MAPPED,&capsA,
1008 winetest_interactive,TRUE,FALSE);
1009 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
1010 CALLBACK_FUNCTION|WAVE_FORMAT_DIRECT,&capsA,
1011 winetest_interactive,TRUE,FALSE);
1012 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
1013 CALLBACK_FUNCTION|WAVE_MAPPED,&capsA,
1014 winetest_interactive,TRUE,FALSE);
1015 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
1016 CALLBACK_THREAD|WAVE_FORMAT_DIRECT,&capsA,
1017 winetest_interactive,TRUE,FALSE);
1018 wave_out_test_deviceOut(device,1.0,1,0,&format,win_formats[f][0],
1019 CALLBACK_THREAD|WAVE_MAPPED,&capsA,
1020 winetest_interactive,TRUE,FALSE);
1021
1022 wave_out_test_deviceOut(device,1.0,10,0,&format,win_formats[f][0],
1023 CALLBACK_EVENT|WAVE_FORMAT_DIRECT,&capsA,
1024 winetest_interactive,TRUE,FALSE);
1025 wave_out_test_deviceOut(device,1.0,5,1,&format,win_formats[f][0],
1026 CALLBACK_EVENT|WAVE_FORMAT_DIRECT,&capsA,
1027 winetest_interactive,TRUE,FALSE);
1028 }
1029 }
1030
1031 /* Try a PCMWAVEFORMAT aligned next to an unaccessible page for bounds
1032 * checking */
1033 twoPages = VirtualAlloc(NULL, 2 * dwPageSize, MEM_RESERVE | MEM_COMMIT,
1034 PAGE_READWRITE);
1035 ok(twoPages!=NULL,"Failed to allocate 2 pages of memory\n");
1036 if (twoPages) {
1037 res = VirtualProtect(twoPages + dwPageSize, dwPageSize, PAGE_NOACCESS,
1038 &flOldProtect);
1039 ok(res, "Failed to set memory access on second page\n");
1040 if (res) {
1041 LPWAVEFORMATEX pwfx = (LPWAVEFORMATEX)(twoPages + dwPageSize -
1042 sizeof(PCMWAVEFORMAT));
1043 pwfx->wFormatTag=WAVE_FORMAT_PCM;
1044 pwfx->nChannels=1;
1045 pwfx->wBitsPerSample=8;
1046 pwfx->nSamplesPerSec=22050;
1047 pwfx->nBlockAlign=pwfx->nChannels*pwfx->wBitsPerSample/8;
1048 pwfx->nAvgBytesPerSec=pwfx->nSamplesPerSec*pwfx->nBlockAlign;
1049 wave_out_test_deviceOut(device,1.0,1,0,pwfx,WAVE_FORMAT_2M08,
1050 CALLBACK_EVENT,&capsA,winetest_interactive,
1051 TRUE,FALSE);
1052 wave_out_test_deviceOut(device,1.0,10,0,pwfx,WAVE_FORMAT_2M08,
1053 CALLBACK_EVENT,&capsA,winetest_interactive,
1054 TRUE,FALSE);
1055 wave_out_test_deviceOut(device,1.0,5,1,pwfx,WAVE_FORMAT_2M08,
1056 CALLBACK_EVENT,&capsA,winetest_interactive,
1057 TRUE,FALSE);
1058 if (device != WAVE_MAPPER)
1059 {
1060 wave_out_test_deviceOut(device,1.0,1,0,pwfx,WAVE_FORMAT_2M08,
1061 CALLBACK_EVENT|WAVE_FORMAT_DIRECT,
1062 &capsA,winetest_interactive,TRUE,FALSE);
1063 wave_out_test_deviceOut(device,1.0,1,0,pwfx,WAVE_FORMAT_2M08,
1064 CALLBACK_EVENT|WAVE_MAPPED,&capsA,
1065 winetest_interactive,TRUE,FALSE);
1066 wave_out_test_deviceOut(device,1.0,10,0,pwfx,WAVE_FORMAT_2M08,
1067 CALLBACK_EVENT|WAVE_FORMAT_DIRECT,
1068 &capsA,winetest_interactive,TRUE,FALSE);
1069 wave_out_test_deviceOut(device,1.0,10,0,pwfx,WAVE_FORMAT_2M08,
1070 CALLBACK_EVENT|WAVE_MAPPED,&capsA,
1071 winetest_interactive,TRUE,FALSE);
1072 wave_out_test_deviceOut(device,1.0,5,1,pwfx,WAVE_FORMAT_2M08,
1073 CALLBACK_EVENT|WAVE_FORMAT_DIRECT,
1074 &capsA,winetest_interactive,TRUE,FALSE);
1075 wave_out_test_deviceOut(device,1.0,5,1,pwfx,WAVE_FORMAT_2M08,
1076 CALLBACK_EVENT|WAVE_MAPPED,&capsA,
1077 winetest_interactive,TRUE,FALSE);
1078 }
1079 }
1080 VirtualFree(twoPages, 0, MEM_RELEASE);
1081 }
1082
1083 /* Testing invalid format: 11 bits per sample */
1084 format.wFormatTag=WAVE_FORMAT_PCM;
1085 format.nChannels=2;
1086 format.wBitsPerSample=11;
1087 format.nSamplesPerSec=22050;
1088 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
1089 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
1090 format.cbSize=0;
1091 oformat=format;
1092 rc=waveOutOpen(&wout,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1093 ok(rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG ||
1094 rc==MMSYSERR_INVALPARAM,
1095 "waveOutOpen(%s): opening the device in 11 bits mode should fail: "
1096 "rc=%s\n",dev_name(device),wave_out_error(rc));
1097 if (rc==MMSYSERR_NOERROR) {
1098 trace(" got %dx%2dx%d for %dx%2dx%d\n",
1099 format.nSamplesPerSec, format.wBitsPerSample,
1100 format.nChannels,
1101 oformat.nSamplesPerSec, oformat.wBitsPerSample,
1102 oformat.nChannels);
1103 waveOutClose(wout);
1104 }
1105
1106 /* Testing invalid format: 2 MHz sample rate */
1107 format.wFormatTag=WAVE_FORMAT_PCM;
1108 format.nChannels=2;
1109 format.wBitsPerSample=16;
1110 format.nSamplesPerSec=2000000;
1111 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
1112 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
1113 format.cbSize=0;
1114 oformat=format;
1115 rc=waveOutOpen(&wout,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1116 ok(rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG ||
1117 rc==MMSYSERR_INVALPARAM,
1118 "waveOutOpen(%s): opening the device at 2 MHz sample rate should fail: "
1119 "rc=%s\n",dev_name(device),wave_out_error(rc));
1120 if (rc==MMSYSERR_NOERROR) {
1121 trace(" got %dx%2dx%d for %dx%2dx%d\n",
1122 format.nSamplesPerSec, format.wBitsPerSample,
1123 format.nChannels,
1124 oformat.nSamplesPerSec, oformat.wBitsPerSample,
1125 oformat.nChannels);
1126 waveOutClose(wout);
1127 }
1128
1129 /* try some non PCM formats */
1130 format.wFormatTag=WAVE_FORMAT_MULAW;
1131 format.nChannels=1;
1132 format.wBitsPerSample=8;
1133 format.nSamplesPerSec=8000;
1134 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
1135 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
1136 format.cbSize=0;
1137 oformat=format;
1138 rc=waveOutOpen(&wout,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1139 ok(rc==MMSYSERR_NOERROR ||rc==WAVERR_BADFORMAT ||
1140 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1141 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1142 if (rc==MMSYSERR_NOERROR) {
1143 waveOutClose(wout);
1144 wave_out_test_deviceOut(device,1.0,1,0,&format,0,CALLBACK_EVENT,
1145 &capsA,winetest_interactive,TRUE,FALSE);
1146 wave_out_test_deviceOut(device,1.0,10,0,&format,0,CALLBACK_EVENT,
1147 &capsA,winetest_interactive,TRUE,FALSE);
1148 wave_out_test_deviceOut(device,1.0,5,1,&format,0,CALLBACK_EVENT,
1149 &capsA,winetest_interactive,TRUE,FALSE);
1150 } else
1151 trace("waveOutOpen(%s): WAVE_FORMAT_MULAW not supported\n",
1152 dev_name(device));
1153
1154 format.wFormatTag=WAVE_FORMAT_ADPCM;
1155 format.nChannels=2;
1156 format.wBitsPerSample=4;
1157 format.nSamplesPerSec=22050;
1158 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
1159 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
1160 format.cbSize=0;
1161 oformat=format;
1162 rc=waveOutOpen(&wout,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1163 ok(rc==MMSYSERR_NOERROR ||rc==WAVERR_BADFORMAT ||
1164 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1165 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1166 if (rc==MMSYSERR_NOERROR) {
1167 waveOutClose(wout);
1168 wave_out_test_deviceOut(device,1.0,1,0,&format,0,CALLBACK_EVENT,
1169 &capsA,winetest_interactive,TRUE,FALSE);
1170 wave_out_test_deviceOut(device,1.0,10,0,&format,0,CALLBACK_EVENT,
1171 &capsA,winetest_interactive,TRUE,FALSE);
1172 wave_out_test_deviceOut(device,1.0,5,1,&format,0,CALLBACK_EVENT,
1173 &capsA,winetest_interactive,TRUE,FALSE);
1174 } else
1175 trace("waveOutOpen(%s): WAVE_FORMAT_ADPCM not supported\n",
1176 dev_name(device));
1177
1178 /* test if WAVEFORMATEXTENSIBLE supported */
1179 wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
1180 wfex.Format.nChannels=2;
1181 wfex.Format.wBitsPerSample=16;
1182 wfex.Format.nSamplesPerSec=22050;
1183 wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
1184 wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
1185 wfex.Format.nBlockAlign;
1186 wfex.Format.cbSize=22;
1187 wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
1188 wfex.dwChannelMask=SPEAKER_ALL;
1189 wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
1190 rc=waveOutOpen(&wout,device,&wfex.Format,0,0,
1191 CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1192 ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
1193 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1194 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1195 if (rc==MMSYSERR_NOERROR) {
1196 waveOutClose(wout);
1197 wave_out_test_deviceOut(device,1.0,1,0,&wfex.Format,WAVE_FORMAT_2M16,
1198 CALLBACK_EVENT,&capsA,winetest_interactive,
1199 TRUE,FALSE);
1200 wave_out_test_deviceOut(device,1.0,10,0,&wfex.Format,WAVE_FORMAT_2M16,
1201 CALLBACK_EVENT,&capsA,winetest_interactive,
1202 TRUE,FALSE);
1203 wave_out_test_deviceOut(device,1.0,5,1,&wfex.Format,WAVE_FORMAT_2M16,
1204 CALLBACK_EVENT,&capsA,winetest_interactive,
1205 TRUE,FALSE);
1206 } else
1207 trace("waveOutOpen(%s): WAVE_FORMAT_EXTENSIBLE not supported\n",
1208 dev_name(device));
1209
1210 /* test if 4 channels supported */
1211 wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
1212 wfex.Format.nChannels=4;
1213 wfex.Format.wBitsPerSample=16;
1214 wfex.Format.nSamplesPerSec=22050;
1215 wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
1216 wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
1217 wfex.Format.nBlockAlign;
1218 wfex.Format.cbSize=22;
1219 wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
1220 wfex.dwChannelMask=SPEAKER_ALL;
1221 wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
1222 rc=waveOutOpen(&wout,device,&wfex.Format,0,0,
1223 CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1224 ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
1225 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1226 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1227 if (rc==MMSYSERR_NOERROR) {
1228 waveOutClose(wout);
1229 wave_out_test_deviceOut(device,1.0,1,0,&wfex.Format,0,CALLBACK_EVENT,
1230 &capsA,winetest_interactive,TRUE,FALSE);
1231 wave_out_test_deviceOut(device,1.0,10,0,&wfex.Format,0,CALLBACK_EVENT,
1232 &capsA,winetest_interactive,TRUE,FALSE);
1233 wave_out_test_deviceOut(device,1.0,5,1,&wfex.Format,0,CALLBACK_EVENT,
1234 &capsA,winetest_interactive,TRUE,FALSE);
1235 } else
1236 trace("waveOutOpen(%s): 4 channels not supported\n",
1237 dev_name(device));
1238
1239 /* test if 6 channels supported */
1240 wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
1241 wfex.Format.nChannels=6;
1242 wfex.Format.wBitsPerSample=16;
1243 wfex.Format.nSamplesPerSec=22050;
1244 wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
1245 wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
1246 wfex.Format.nBlockAlign;
1247 wfex.Format.cbSize=22;
1248 wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
1249 wfex.dwChannelMask=SPEAKER_ALL;
1250 wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
1251 rc=waveOutOpen(&wout,device,&wfex.Format,0,0,
1252 CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1253 ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
1254 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1255 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1256 if (rc==MMSYSERR_NOERROR) {
1257 waveOutClose(wout);
1258 wave_out_test_deviceOut(device,1.0,1,0,&wfex.Format,WAVE_FORMAT_2M16,
1259 CALLBACK_EVENT,&capsA,winetest_interactive,
1260 TRUE,FALSE);
1261 wave_out_test_deviceOut(device,1.0,10,0,&wfex.Format,WAVE_FORMAT_2M16,
1262 CALLBACK_EVENT,&capsA,winetest_interactive,
1263 TRUE,FALSE);
1264 wave_out_test_deviceOut(device,1.0,5,1,&wfex.Format,WAVE_FORMAT_2M16,
1265 CALLBACK_EVENT,&capsA,winetest_interactive,
1266 TRUE,FALSE);
1267 } else
1268 trace("waveOutOpen(%s): 6 channels not supported\n",
1269 dev_name(device));
1270
1271 if (0)
1272 {
1273 /* FIXME: ALSA doesn't like this format */
1274 /* test if 24 bit samples supported */
1275 wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
1276 wfex.Format.nChannels=2;
1277 wfex.Format.wBitsPerSample=24;
1278 wfex.Format.nSamplesPerSec=22050;
1279 wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
1280 wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
1281 wfex.Format.nBlockAlign;
1282 wfex.Format.cbSize=22;
1283 wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
1284 wfex.dwChannelMask=SPEAKER_ALL;
1285 wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
1286 rc=waveOutOpen(&wout,device,&wfex.Format,0,0,
1287 CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1288 ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
1289 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1290 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1291 if (rc==MMSYSERR_NOERROR) {
1292 waveOutClose(wout);
1293 wave_out_test_deviceOut(device,1.0,1,0,&wfex.Format,WAVE_FORMAT_2M16,
1294 CALLBACK_EVENT,&capsA,winetest_interactive,
1295 TRUE,FALSE);
1296 } else
1297 trace("waveOutOpen(%s): 24 bit samples not supported\n",
1298 dev_name(device));
1299 }
1300
1301 /* test if 32 bit samples supported */
1302 wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
1303 wfex.Format.nChannels=2;
1304 wfex.Format.wBitsPerSample=32;
1305 wfex.Format.nSamplesPerSec=22050;
1306 wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
1307 wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
1308 wfex.Format.nBlockAlign;
1309 wfex.Format.cbSize=22;
1310 wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
1311 wfex.dwChannelMask=SPEAKER_ALL;
1312 wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM;
1313 rc=waveOutOpen(&wout,device,&wfex.Format,0,0,
1314 CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1315 ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
1316 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1317 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1318 if (rc==MMSYSERR_NOERROR) {
1319 waveOutClose(wout);
1320 wave_out_test_deviceOut(device,1.0,1,0,&wfex.Format,WAVE_FORMAT_2M16,
1321 CALLBACK_EVENT,&capsA,winetest_interactive,
1322 TRUE,FALSE);
1323 wave_out_test_deviceOut(device,1.0,10,0,&wfex.Format,WAVE_FORMAT_2M16,
1324 CALLBACK_EVENT,&capsA,winetest_interactive,
1325 TRUE,FALSE);
1326 wave_out_test_deviceOut(device,1.0,5,1,&wfex.Format,WAVE_FORMAT_2M16,
1327 CALLBACK_EVENT,&capsA,winetest_interactive,
1328 TRUE,FALSE);
1329 } else
1330 trace("waveOutOpen(%s): 32 bit samples not supported\n",
1331 dev_name(device));
1332
1333 /* test if 32 bit float samples supported */
1334 wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE;
1335 wfex.Format.nChannels=2;
1336 wfex.Format.wBitsPerSample=32;
1337 wfex.Format.nSamplesPerSec=22050;
1338 wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
1339 wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*
1340 wfex.Format.nBlockAlign;
1341 wfex.Format.cbSize=22;
1342 wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
1343 wfex.dwChannelMask=SPEAKER_ALL;
1344 wfex.SubFormat=KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
1345 rc=waveOutOpen(&wout,device,&wfex.Format,0,0,
1346 CALLBACK_NULL|WAVE_FORMAT_DIRECT);
1347 ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT ||
1348 rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM,
1349 "waveOutOpen(%s): returned %s\n",dev_name(device),wave_out_error(rc));
1350 if (rc==MMSYSERR_NOERROR) {
1351 waveOutClose(wout);
1352 wave_out_test_deviceOut(device,1.0,1,0,&wfex.Format,WAVE_FORMAT_2M16,
1353 CALLBACK_EVENT,&capsA,winetest_interactive,
1354 TRUE,FALSE);
1355 wave_out_test_deviceOut(device,1.0,10,0,&wfex.Format,WAVE_FORMAT_2M16,
1356 CALLBACK_EVENT,&capsA,winetest_interactive,
1357 TRUE,FALSE);
1358 wave_out_test_deviceOut(device,1.0,5,1,&wfex.Format,WAVE_FORMAT_2M16,
1359 CALLBACK_EVENT,&capsA,winetest_interactive,
1360 TRUE,FALSE);
1361 } else
1362 trace("waveOutOpen(%s): 32 bit float samples not supported\n",
1363 dev_name(device));
1364 }
1365
1366 static void wave_out_tests(void)
1367 {
1368 WAVEOUTCAPSA capsA;
1369 WAVEOUTCAPSW capsW;
1370 WAVEFORMATEX format;
1371 HWAVEOUT wout;
1372 MMRESULT rc;
1373 UINT ndev,d;
1374
1375 ndev=waveOutGetNumDevs();
1376 trace("found %d WaveOut devices\n",ndev);
1377
1378 rc=waveOutGetDevCapsA(ndev+1,&capsA,sizeof(capsA));
1379 ok(rc==MMSYSERR_BADDEVICEID,
1380 "waveOutGetDevCapsA(%s): MMSYSERR_BADDEVICEID expected, got %s\n",
1381 dev_name(ndev+1),mmsys_error(rc));
1382
1383 rc=waveOutGetDevCapsW(ndev+1,&capsW,sizeof(capsW));
1384 ok(rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NOTSUPPORTED,
1385 "waveOutGetDevCapsW(%s): MMSYSERR_BADDEVICEID or MMSYSERR_NOTSUPPORTED "
1386 "expected, got %s\n",dev_name(ndev+1),mmsys_error(rc));
1387
1388 rc=waveOutGetDevCapsA(WAVE_MAPPER,&capsA,sizeof(capsA));
1389 if (ndev>0)
1390 ok(rc==MMSYSERR_NOERROR,
1391 "waveOutGetDevCapsA(%s): MMSYSERR_NOERROR expected, got %s\n",
1392 dev_name(WAVE_MAPPER),mmsys_error(rc));
1393 else
1394 ok(rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NODRIVER,
1395 "waveOutGetDevCapsA(%s): MMSYSERR_BADDEVICEID or MMSYSERR_NODRIVER "
1396 "expected, got %s\n",dev_name(WAVE_MAPPER),mmsys_error(rc));
1397
1398 rc=waveOutGetDevCapsW(WAVE_MAPPER,&capsW,sizeof(capsW));
1399 if (ndev>0)
1400 ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NOTSUPPORTED,
1401 "waveOutGetDevCapsW(%s): MMSYSERR_NOERROR or MMSYSERR_NOTSUPPORTED "
1402 "expected, got %s\n",dev_name(WAVE_MAPPER),mmsys_error(rc));
1403 else
1404 ok(rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NODRIVER ||
1405 rc==MMSYSERR_NOTSUPPORTED,
1406 "waveOutGetDevCapsW(%s): MMSYSERR_BADDEVICEID or MMSYSERR_NODRIVER "
1407 " or MMSYSERR_NOTSUPPORTED expected, got %s\n",
1408 dev_name(WAVE_MAPPER),mmsys_error(rc));
1409
1410 format.wFormatTag=WAVE_FORMAT_PCM;
1411 format.nChannels=2;
1412 format.wBitsPerSample=16;
1413 format.nSamplesPerSec=44100;
1414 format.nBlockAlign=format.nChannels*format.wBitsPerSample/8;
1415 format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign;
1416 format.cbSize=0;
1417 rc=waveOutOpen(&wout,ndev+1,&format,0,0,CALLBACK_NULL);
1418 ok(rc==MMSYSERR_BADDEVICEID,
1419 "waveOutOpen(%s): MMSYSERR_BADDEVICEID expected, got %s\n",
1420 dev_name(ndev+1),mmsys_error(rc));
1421
1422 for (d=0;d<ndev;d++)
1423 wave_out_test_device(d);
1424
1425 if (ndev>0)
1426 wave_out_test_device(WAVE_MAPPER);
1427 }
1428
1429 START_TEST(wave)
1430 {
1431 wave_out_tests();
1432 }
Windows API implementation