?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't try to find alternate formats for non PCM formats.
[wine/wine64.git] / dlls / winmm / wavemap / wavemap.c
blob41a5ebe389110f5dbdbb4424da54a183ea5db264
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3 * Wine Wave mapper driver
4 *
5 * Copyright 1999,2001 Eric Pouech
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* TODOs
23 * + better protection against evilish dwUser parameters
24 * + use asynchronous ACM conversion
25 * + don't use callback functions when none is required in open
26 * + the buffer sizes may not be accurate, so there may be some
27 * remaining bytes in src and dst buffers after ACM conversions...
28 * those should be taken care of...
29 */
30
31 #include <stdarg.h>
32 #include <string.h>
33 #include "windef.h"
34 #include "winbase.h"
35 #include "wingdi.h"
36 #include "winuser.h"
37 #include "mmddk.h"
38 #include "mmreg.h"
39 #include "msacm.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(wavemap);
43
44 typedef struct tagWAVEMAPDATA {
45 struct tagWAVEMAPDATA* self;
46 union {
47 struct {
48 HWAVEOUT hOuterWave;
49 HWAVEOUT hInnerWave;
50 } out;
51 struct {
52 HWAVEIN hOuterWave;
53 HWAVEIN hInnerWave;
54 } in;
55 } u;
56 HACMSTREAM hAcmStream;
57 /* needed data to filter callbacks. Only needed when hAcmStream is not 0 */
58 DWORD dwCallback;
59 DWORD dwClientInstance;
60 DWORD dwFlags;
61 /* ratio to compute position from a PCM playback to any format */
62 DWORD avgSpeedOuter;
63 DWORD avgSpeedInner;
64 } WAVEMAPDATA;
65
66 static BOOL WAVEMAP_IsData(WAVEMAPDATA* wm)
67 {
68 return (!IsBadReadPtr(wm, sizeof(WAVEMAPDATA)) && wm->self == wm);
69 }
70
71 /*======================================================================*
72 * WAVE OUT part *
73 *======================================================================*/
74
75 static void CALLBACK wodCallback(HWAVEOUT hWave, UINT uMsg, DWORD dwInstance,
76 DWORD dwParam1, DWORD dwParam2)
77 {
78 WAVEMAPDATA* wom = (WAVEMAPDATA*)dwInstance;
79
80 TRACE("(%p %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
81
82 if (!WAVEMAP_IsData(wom)) {
83 ERR("Bad data\n");
84 return;
85 }
86
87 if (hWave != wom->u.out.hInnerWave && uMsg != WOM_OPEN)
88 ERR("Shouldn't happen (%p %p)\n", hWave, wom->u.out.hInnerWave);
89
90 switch (uMsg) {
91 case WOM_OPEN:
92 case WOM_CLOSE:
93 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
94 break;
95 case WOM_DONE:
96 if (wom->hAcmStream) {
97 LPWAVEHDR lpWaveHdrDst = (LPWAVEHDR)dwParam1;
98 PACMSTREAMHEADER ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrDst - sizeof(ACMSTREAMHEADER));
99 LPWAVEHDR lpWaveHdrSrc = (LPWAVEHDR)ash->dwUser;
100
101 lpWaveHdrSrc->dwFlags &= ~WHDR_INQUEUE;
102 lpWaveHdrSrc->dwFlags |= WHDR_DONE;
103 dwParam1 = (DWORD)lpWaveHdrSrc;
104 }
105 break;
106 default:
107 ERR("Unknown msg %u\n", uMsg);
108 }
109
110 DriverCallback(wom->dwCallback, HIWORD(wom->dwFlags), (HDRVR)wom->u.out.hOuterWave,
111 uMsg, wom->dwClientInstance, dwParam1, dwParam2);
112 }
113
114 /******************************************************************
115 * wodOpenHelper
116 *
117 *
118 */
119 static DWORD wodOpenHelper(WAVEMAPDATA* wom, UINT idx,
120 LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
121 DWORD dwFlags)
122 {
123 DWORD ret;
124
125 TRACE("(%p %04x %p %p %08lx)\n", wom, idx, lpDesc, lpwfx, dwFlags);
126
127 /* destination is always PCM, so the formulas below apply */
128 lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
129 lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
130 if (dwFlags & WAVE_FORMAT_QUERY) {
131 ret = acmStreamOpen(NULL, 0, lpDesc->lpFormat, lpwfx, NULL, 0L, 0L, ACM_STREAMOPENF_QUERY);
132 } else {
133 ret = acmStreamOpen(&wom->hAcmStream, 0, lpDesc->lpFormat, lpwfx, NULL, 0L, 0L, 0L);
134 }
135 if (ret == MMSYSERR_NOERROR) {
136 ret = waveOutOpen(&wom->u.out.hInnerWave, idx, lpwfx, (DWORD)wodCallback,
137 (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
138 if (ret != MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY)) {
139 acmStreamClose(wom->hAcmStream, 0);
140 wom->hAcmStream = 0;
141 }
142 }
143 TRACE("ret = %08lx\n", ret);
144 return ret;
145 }
146
147 static DWORD wodOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
148 {
149 UINT ndlo, ndhi;
150 UINT i;
151 WAVEMAPDATA* wom = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
152 DWORD res;
153
154 TRACE("(%p %p %08lx)\n", lpdwUser, lpDesc, dwFlags);
155
156 if (!wom) {
157 WARN("no memory\n");
158 return MMSYSERR_NOMEM;
159 }
160
161 ndhi = waveOutGetNumDevs();
162 if (dwFlags & WAVE_MAPPED) {
163 if (lpDesc->uMappedDeviceID >= ndhi) {
164 WARN("invalid parameter: dwFlags WAVE_MAPPED\n");
165 return MMSYSERR_INVALPARAM;
166 }
167 ndlo = lpDesc->uMappedDeviceID;
168 ndhi = ndlo + 1;
169 dwFlags &= ~WAVE_MAPPED;
170 } else {
171 ndlo = 0;
172 }
173 wom->self = wom;
174 wom->dwCallback = lpDesc->dwCallback;
175 wom->dwFlags = dwFlags;
176 wom->dwClientInstance = lpDesc->dwInstance;
177 wom->u.out.hOuterWave = (HWAVEOUT)lpDesc->hWave;
178 wom->avgSpeedOuter = wom->avgSpeedInner = lpDesc->lpFormat->nAvgBytesPerSec;
179
180 for (i = ndlo; i < ndhi; i++) {
181 /* if no ACM stuff is involved, no need to handle callbacks at this
182 * level, this will be done transparently
183 */
184 if (waveOutOpen(&wom->u.out.hInnerWave, i, lpDesc->lpFormat, (DWORD)wodCallback,
185 (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
186 wom->hAcmStream = 0;
187 goto found;
188 }
189 }
190
191 if ((dwFlags & WAVE_FORMAT_DIRECT) == 0 && lpDesc->lpFormat->wFormatTag == WAVE_FORMAT_PCM) {
192 WAVEFORMATEX wfx;
193
194 wfx.wFormatTag = WAVE_FORMAT_PCM;
195 wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
196 /* try some ACM stuff */
197
198 #define TRY(sps,bps) wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
199 switch (res=wodOpenHelper(wom, i, lpDesc, &wfx, dwFlags | WAVE_FORMAT_DIRECT)) { \
200 case MMSYSERR_NOERROR: wom->avgSpeedInner = wfx.nAvgBytesPerSec; goto found; \
201 case WAVERR_BADFORMAT: break; \
202 default: goto error; \
203 }
204
205 /* Our resampling algorithm is quite primitive so first try
206 * to just change the bit depth and number of channels
207 */
208 for (i = ndlo; i < ndhi; i++) {
209 wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
210 wfx.nChannels = lpDesc->lpFormat->nChannels;
211 TRY(wfx.nSamplesPerSec, 16);
212 TRY(wfx.nSamplesPerSec, 8);
213 wfx.nChannels ^= 3;
214 TRY(wfx.nSamplesPerSec, 16);
215 TRY(wfx.nSamplesPerSec, 8);
216 }
217
218 for (i = ndlo; i < ndhi; i++) {
219 /* first try with same stereo/mono option as source */
220 wfx.nChannels = lpDesc->lpFormat->nChannels;
221 TRY(96000, 16);
222 TRY(48000, 16);
223 TRY(44100, 16);
224 TRY(22050, 16);
225 TRY(11025, 16);
226
227 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
228 wfx.nChannels ^= 3;
229 TRY(96000, 16);
230 TRY(48000, 16);
231 TRY(44100, 16);
232 TRY(22050, 16);
233 TRY(11025, 16);
234
235 /* first try with same stereo/mono option as source */
236 wfx.nChannels = lpDesc->lpFormat->nChannels;
237 TRY(96000, 8);
238 TRY(48000, 8);
239 TRY(44100, 8);
240 TRY(22050, 8);
241 TRY(11025, 8);
242
243 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
244 wfx.nChannels ^= 3;
245 TRY(96000, 8);
246 TRY(48000, 8);
247 TRY(44100, 8);
248 TRY(22050, 8);
249 TRY(11025, 8);
250 }
251 #undef TRY
252 }
253
254 HeapFree(GetProcessHeap(), 0, wom);
255 WARN("ret = WAVERR_BADFORMAT\n");
256 return WAVERR_BADFORMAT;
257
258 found:
259 if (dwFlags & WAVE_FORMAT_QUERY) {
260 *lpdwUser = 0L;
261 HeapFree(GetProcessHeap(), 0, wom);
262 } else {
263 *lpdwUser = (DWORD)wom;
264 }
265 return MMSYSERR_NOERROR;
266 error:
267 HeapFree(GetProcessHeap(), 0, wom);
268 if (res==ACMERR_NOTPOSSIBLE) {
269 WARN("ret = WAVERR_BADFORMAT\n");
270 return WAVERR_BADFORMAT;
271 }
272 WARN("ret = MMSYSERR_ERROR\n");
273 return MMSYSERR_ERROR;
274 }
275
276 static DWORD wodClose(WAVEMAPDATA* wom)
277 {
278 DWORD ret;
279
280 TRACE("(%p)\n", wom);
281
282 ret = waveOutClose(wom->u.out.hInnerWave);
283 if (ret == MMSYSERR_NOERROR) {
284 if (wom->hAcmStream) {
285 ret = acmStreamClose(wom->hAcmStream, 0);
286 }
287 if (ret == MMSYSERR_NOERROR) {
288 HeapFree(GetProcessHeap(), 0, wom);
289 }
290 }
291 return ret;
292 }
293
294 static DWORD wodWrite(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
295 {
296 PACMSTREAMHEADER ash;
297 LPWAVEHDR lpWaveHdrDst;
298
299 TRACE("(%p %p %08lx)\n", wom, lpWaveHdrSrc, dwParam2);
300
301 if (!wom->hAcmStream) {
302 return waveOutWrite(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
303 }
304
305 lpWaveHdrSrc->dwFlags |= WHDR_INQUEUE;
306 ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
307 /* acmStreamConvert will actually check that the new size is less than initial size */
308 ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
309 if (acmStreamConvert(wom->hAcmStream, ash, 0L) != MMSYSERR_NOERROR) {
310 WARN("acmStreamConvert failed\n");
311 return MMSYSERR_ERROR;
312 }
313
314 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
315 if (ash->cbSrcLength > ash->cbSrcLengthUsed)
316 FIXME("Not all src buffer has been written, expect bogus sound\n");
317 else if (ash->cbSrcLength < ash->cbSrcLengthUsed)
318 ERR("CoDec has read more data than it is allowed to\n");
319
320 if (ash->cbDstLengthUsed == 0) {
321 /* something went wrong in decoding */
322 FIXME("Got 0 length\n");
323 return MMSYSERR_ERROR;
324 }
325 lpWaveHdrDst->dwBufferLength = ash->cbDstLengthUsed;
326 return waveOutWrite(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
327 }
328
329 static DWORD wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
330 {
331 PACMSTREAMHEADER ash;
332 DWORD size;
333 DWORD dwRet;
334 LPWAVEHDR lpWaveHdrDst;
335
336 TRACE("(%p %p %08lx)\n", wom, lpWaveHdrSrc, dwParam2);
337
338 if (!wom->hAcmStream)
339 return waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
340
341 if (acmStreamSize(wom->hAcmStream, lpWaveHdrSrc->dwBufferLength, &size, ACM_STREAMSIZEF_SOURCE) != MMSYSERR_NOERROR) {
342 WARN("acmStreamSize failed\n");
343 return MMSYSERR_ERROR;
344 }
345
346 ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
347 if (ash == NULL) {
348 WARN("no memory\n");
349 return MMSYSERR_NOMEM;
350 }
351
352 ash->cbStruct = sizeof(*ash);
353 ash->fdwStatus = 0L;
354 ash->dwUser = (DWORD)lpWaveHdrSrc;
355 ash->pbSrc = lpWaveHdrSrc->lpData;
356 ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
357 /* ash->cbSrcLengthUsed */
358 ash->dwSrcUser = lpWaveHdrSrc->dwUser; /* FIXME ? */
359 ash->pbDst = (LPSTR)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
360 ash->cbDstLength = size;
361 /* ash->cbDstLengthUsed */
362 ash->dwDstUser = 0; /* FIXME ? */
363 dwRet = acmStreamPrepareHeader(wom->hAcmStream, ash, 0L);
364 if (dwRet != MMSYSERR_NOERROR) {
365 WARN("acmStreamPrepareHeader failed\n");
366 goto errCleanUp;
367 }
368
369 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
370 lpWaveHdrDst->lpData = ash->pbDst;
371 lpWaveHdrDst->dwBufferLength = size; /* conversion is not done yet */
372 lpWaveHdrDst->dwFlags = 0;
373 lpWaveHdrDst->dwLoops = 0;
374 dwRet = waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
375 if (dwRet != MMSYSERR_NOERROR) {
376 WARN("waveOutPrepareHeader failed\n");
377 goto errCleanUp;
378 }
379
380 lpWaveHdrSrc->reserved = (DWORD)ash;
381 lpWaveHdrSrc->dwFlags = WHDR_PREPARED;
382 TRACE("=> (0)\n");
383 return MMSYSERR_NOERROR;
384 errCleanUp:
385 TRACE("=> (%ld)\n", dwRet);
386 HeapFree(GetProcessHeap(), 0, ash);
387 return dwRet;
388 }
389
390 static DWORD wodUnprepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
391 {
392 PACMSTREAMHEADER ash;
393 LPWAVEHDR lpWaveHdrDst;
394 DWORD dwRet1, dwRet2;
395
396 TRACE("(%p %p %08lx)\n", wom, lpWaveHdrSrc, dwParam2);
397
398 if (!wom->hAcmStream) {
399 return waveOutUnprepareHeader(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
400 }
401 ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
402 dwRet1 = acmStreamUnprepareHeader(wom->hAcmStream, ash, 0L);
403
404 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
405 dwRet2 = waveOutUnprepareHeader(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
406
407 HeapFree(GetProcessHeap(), 0, ash);
408
409 lpWaveHdrSrc->dwFlags &= ~WHDR_PREPARED;
410 return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
411 }
412
413 static DWORD wodGetPosition(WAVEMAPDATA* wom, LPMMTIME lpTime, DWORD dwParam2)
414 {
415 DWORD val;
416 TRACE("(%p %p %08lx)\n", wom, lpTime, dwParam2);
417
418 val = waveOutGetPosition(wom->u.out.hInnerWave, lpTime, dwParam2);
419 if (lpTime->wType == TIME_BYTES)
420 lpTime->u.cb = MulDiv(lpTime->u.cb, wom->avgSpeedOuter, wom->avgSpeedInner);
421 /* other time types don't require conversion */
422 return val;
423 }
424
425 static DWORD wodGetDevCaps(UINT wDevID, WAVEMAPDATA* wom, LPWAVEOUTCAPSA lpWaveCaps, DWORD dwParam2)
426 {
427 TRACE("(%04x %p %p %08lx)\n",wDevID, wom, lpWaveCaps, dwParam2);
428
429 /* if opened low driver, forward message */
430 if (WAVEMAP_IsData(wom))
431 return waveOutGetDevCapsA((UINT)wom->u.out.hInnerWave, lpWaveCaps, dwParam2);
432 /* else if no drivers, nothing to map so return bad device */
433 if (waveOutGetNumDevs() == 0) {
434 WARN("bad device id\n");
435 return MMSYSERR_BADDEVICEID;
436 }
437 /* otherwise, return caps of mapper itself */
438 if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
439 WAVEOUTCAPSA woc;
440 woc.wMid = 0x00FF;
441 woc.wPid = 0x0001;
442 woc.vDriverVersion = 0x0100;
443 strcpy(woc.szPname, "Wine wave out mapper");
444 woc.dwFormats =
445 WAVE_FORMAT_96M08 | WAVE_FORMAT_96S08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16 |
446 WAVE_FORMAT_48M08 | WAVE_FORMAT_48S08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S16 |
447 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
448 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
449 WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
450 woc.wChannels = 2;
451 woc.dwSupport = WAVECAPS_VOLUME | WAVECAPS_LRVOLUME;
452 memcpy(lpWaveCaps, &woc, min(dwParam2, sizeof(woc)));
453
454 return MMSYSERR_NOERROR;
455 }
456 ERR("This shouldn't happen\n");
457 return MMSYSERR_ERROR;
458 }
459
460 static DWORD wodGetVolume(UINT wDevID, WAVEMAPDATA* wom, LPDWORD lpVol)
461 {
462 TRACE("(%04x %p %p)\n",wDevID, wom, lpVol);
463
464 if (WAVEMAP_IsData(wom))
465 return waveOutGetVolume(wom->u.out.hInnerWave, lpVol);
466 return MMSYSERR_NOERROR;
467 }
468
469 static DWORD wodSetVolume(UINT wDevID, WAVEMAPDATA* wom, DWORD vol)
470 {
471 TRACE("(%04x %p %08lx)\n",wDevID, wom, vol);
472
473 if (WAVEMAP_IsData(wom))
474 return waveOutSetVolume(wom->u.out.hInnerWave, vol);
475 return MMSYSERR_NOERROR;
476 }
477
478 static DWORD wodPause(WAVEMAPDATA* wom)
479 {
480 TRACE("(%p)\n",wom);
481
482 return waveOutPause(wom->u.out.hInnerWave);
483 }
484
485 static DWORD wodRestart(WAVEMAPDATA* wom)
486 {
487 TRACE("(%p)\n",wom);
488
489 return waveOutRestart(wom->u.out.hInnerWave);
490 }
491
492 static DWORD wodReset(WAVEMAPDATA* wom)
493 {
494 TRACE("(%p)\n",wom);
495
496 return waveOutReset(wom->u.out.hInnerWave);
497 }
498
499 static DWORD wodBreakLoop(WAVEMAPDATA* wom)
500 {
501 TRACE("(%p)\n",wom);
502
503 return waveOutBreakLoop(wom->u.out.hInnerWave);
504 }
505
506 static DWORD wodMapperStatus(WAVEMAPDATA* wom, DWORD flags, LPVOID ptr)
507 {
508 UINT id;
509 DWORD ret = MMSYSERR_NOTSUPPORTED;
510
511 TRACE("(%p %08lx %p)\n",wom, flags, ptr);
512
513 switch (flags) {
514 case WAVEOUT_MAPPER_STATUS_DEVICE:
515 ret = waveOutGetID(wom->u.out.hInnerWave, &id);
516 *(LPDWORD)ptr = id;
517 break;
518 case WAVEOUT_MAPPER_STATUS_MAPPED:
519 FIXME("Unsupported flag=%ld\n", flags);
520 *(LPDWORD)ptr = 0; /* FIXME ?? */
521 break;
522 case WAVEOUT_MAPPER_STATUS_FORMAT:
523 FIXME("Unsupported flag=%ld\n", flags);
524 /* ptr points to a WAVEFORMATEX struct - before or after streaming ? */
525 *(LPDWORD)ptr = 0;
526 break;
527 default:
528 FIXME("Unsupported flag=%ld\n", flags);
529 *(LPDWORD)ptr = 0;
530 break;
531 }
532 return ret;
533 }
534
535 /**************************************************************************
536 * wodMessage (MSACM.@)
537 */
538 DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
539 DWORD dwParam1, DWORD dwParam2)
540 {
541 TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
542 wDevID, wMsg, dwUser, dwParam1, dwParam2);
543
544 switch (wMsg) {
545 case DRVM_INIT:
546 case DRVM_EXIT:
547 case DRVM_ENABLE:
548 case DRVM_DISABLE:
549 /* FIXME: Pretend this is supported */
550 return 0;
551 case WODM_OPEN: return wodOpen ((LPDWORD)dwUser, (LPWAVEOPENDESC)dwParam1,dwParam2);
552 case WODM_CLOSE: return wodClose ((WAVEMAPDATA*)dwUser);
553 case WODM_WRITE: return wodWrite ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
554 case WODM_PAUSE: return wodPause ((WAVEMAPDATA*)dwUser);
555 case WODM_GETPOS: return wodGetPosition ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1, dwParam2);
556 case WODM_BREAKLOOP: return wodBreakLoop ((WAVEMAPDATA*)dwUser);
557 case WODM_PREPARE: return wodPrepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
558 case WODM_UNPREPARE: return wodUnprepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
559 case WODM_GETDEVCAPS: return wodGetDevCaps (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEOUTCAPSA)dwParam1,dwParam2);
560 case WODM_GETNUMDEVS: return 1;
561 case WODM_GETPITCH: return MMSYSERR_NOTSUPPORTED;
562 case WODM_SETPITCH: return MMSYSERR_NOTSUPPORTED;
563 case WODM_GETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
564 case WODM_SETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
565 case WODM_GETVOLUME: return wodGetVolume (wDevID, (WAVEMAPDATA*)dwUser, (LPDWORD)dwParam1);
566 case WODM_SETVOLUME: return wodSetVolume (wDevID, (WAVEMAPDATA*)dwUser, dwParam1);
567 case WODM_RESTART: return wodRestart ((WAVEMAPDATA*)dwUser);
568 case WODM_RESET: return wodReset ((WAVEMAPDATA*)dwUser);
569 case WODM_MAPPER_STATUS: return wodMapperStatus ((WAVEMAPDATA*)dwUser, dwParam1, (LPVOID)dwParam2);
570 /* known but not supported */
571 case DRV_QUERYDEVICEINTERFACESIZE:
572 case DRV_QUERYDEVICEINTERFACE:
573 return MMSYSERR_NOTSUPPORTED;
574 default:
575 FIXME("unknown message %d!\n", wMsg);
576 }
577 return MMSYSERR_NOTSUPPORTED;
578 }
579
580 /*======================================================================*
581 * WAVE IN part *
582 *======================================================================*/
583
584 static void CALLBACK widCallback(HWAVEIN hWave, UINT uMsg, DWORD dwInstance,
585 DWORD dwParam1, DWORD dwParam2)
586 {
587 WAVEMAPDATA* wim = (WAVEMAPDATA*)dwInstance;
588
589 TRACE("(%p %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
590
591 if (!WAVEMAP_IsData(wim)) {
592 ERR("Bad data\n");
593 return;
594 }
595
596 if (hWave != wim->u.in.hInnerWave && uMsg != WIM_OPEN)
597 ERR("Shouldn't happen (%p %p)\n", hWave, wim->u.in.hInnerWave);
598
599 switch (uMsg) {
600 case WIM_OPEN:
601 case WIM_CLOSE:
602 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
603 break;
604 case WIM_DATA:
605 if (wim->hAcmStream) {
606 LPWAVEHDR lpWaveHdrSrc = (LPWAVEHDR)dwParam1;
607 PACMSTREAMHEADER ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrSrc - sizeof(ACMSTREAMHEADER));
608 LPWAVEHDR lpWaveHdrDst = (LPWAVEHDR)ash->dwUser;
609
610 /* convert data just gotten from waveIn into requested format */
611 if (acmStreamConvert(wim->hAcmStream, ash, 0L) != MMSYSERR_NOERROR) {
612 ERR("ACM conversion failed\n");
613 return;
614 } else {
615 TRACE("Converted %ld bytes into %ld\n", ash->cbSrcLengthUsed, ash->cbDstLengthUsed);
616 }
617 /* and setup the wavehdr to return accordingly */
618 lpWaveHdrDst->dwFlags &= ~WHDR_INQUEUE;
619 lpWaveHdrDst->dwFlags |= WHDR_DONE;
620 lpWaveHdrDst->dwBytesRecorded = ash->cbDstLengthUsed;
621 dwParam1 = (DWORD)lpWaveHdrDst;
622 }
623 break;
624 default:
625 ERR("Unknown msg %u\n", uMsg);
626 }
627
628 DriverCallback(wim->dwCallback, HIWORD(wim->dwFlags), (HDRVR)wim->u.in.hOuterWave,
629 uMsg, wim->dwClientInstance, dwParam1, dwParam2);
630 }
631
632 static DWORD widOpenHelper(WAVEMAPDATA* wim, UINT idx,
633 LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
634 DWORD dwFlags)
635 {
636 DWORD ret;
637
638 TRACE("(%p %04x %p %p %08lx)\n", wim, idx, lpDesc, lpwfx, dwFlags);
639
640 /* source is always PCM, so the formulas below apply */
641 lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
642 lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
643 if (dwFlags & WAVE_FORMAT_QUERY) {
644 ret = acmStreamOpen(NULL, 0, lpwfx, lpDesc->lpFormat, NULL, 0L, 0L, ACM_STREAMOPENF_QUERY);
645 } else {
646 ret = acmStreamOpen(&wim->hAcmStream, 0, lpwfx, lpDesc->lpFormat, NULL, 0L, 0L, 0L);
647 }
648 if (ret == MMSYSERR_NOERROR) {
649 ret = waveInOpen(&wim->u.in.hInnerWave, idx, lpwfx, (DWORD)widCallback,
650 (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
651 if (ret != MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY)) {
652 acmStreamClose(wim->hAcmStream, 0);
653 wim->hAcmStream = 0;
654 }
655 }
656 TRACE("ret = %08lx\n", ret);
657 return ret;
658 }
659
660 static DWORD widOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
661 {
662 UINT ndlo, ndhi;
663 UINT i;
664 WAVEMAPDATA* wim = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
665 DWORD res;
666
667 TRACE("(%p %p %08lx)\n", lpdwUser, lpDesc, dwFlags);
668
669 if (!wim) {
670 WARN("no memory\n");
671 return MMSYSERR_NOMEM;
672 }
673
674 wim->self = wim;
675 wim->dwCallback = lpDesc->dwCallback;
676 wim->dwFlags = dwFlags;
677 wim->dwClientInstance = lpDesc->dwInstance;
678 wim->u.in.hOuterWave = (HWAVEIN)lpDesc->hWave;
679
680 ndhi = waveInGetNumDevs();
681 if (dwFlags & WAVE_MAPPED) {
682 if (lpDesc->uMappedDeviceID >= ndhi) return MMSYSERR_INVALPARAM;
683 ndlo = lpDesc->uMappedDeviceID;
684 ndhi = ndlo + 1;
685 dwFlags &= ~WAVE_MAPPED;
686 } else {
687 ndlo = 0;
688 }
689
690 wim->avgSpeedOuter = wim->avgSpeedInner = lpDesc->lpFormat->nAvgBytesPerSec;
691
692 for (i = ndlo; i < ndhi; i++) {
693 if (waveInOpen(&wim->u.in.hInnerWave, i, lpDesc->lpFormat, (DWORD)widCallback,
694 (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
695 wim->hAcmStream = 0;
696 goto found;
697 }
698 }
699
700 if ((dwFlags & WAVE_FORMAT_DIRECT) == 0)
701 {
702 WAVEFORMATEX wfx;
703
704 wfx.wFormatTag = WAVE_FORMAT_PCM;
705 wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
706 /* try some ACM stuff */
707
708 #define TRY(sps,bps) wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
709 switch (res=widOpenHelper(wim, i, lpDesc, &wfx, dwFlags | WAVE_FORMAT_DIRECT)) { \
710 case MMSYSERR_NOERROR: wim->avgSpeedInner = wfx.nAvgBytesPerSec; goto found; \
711 case WAVERR_BADFORMAT: break; \
712 default: goto error; \
713 }
714
715 for (i = ndlo; i < ndhi; i++) {
716 wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
717 /* first try with same stereo/mono option as source */
718 wfx.nChannels = lpDesc->lpFormat->nChannels;
719 TRY(wfx.nSamplesPerSec, 16);
720 TRY(wfx.nSamplesPerSec, 8);
721 wfx.nChannels ^= 3;
722 TRY(wfx.nSamplesPerSec, 16);
723 TRY(wfx.nSamplesPerSec, 8);
724 }
725
726 for (i = ndlo; i < ndhi; i++) {
727 wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
728 /* first try with same stereo/mono option as source */
729 wfx.nChannels = lpDesc->lpFormat->nChannels;
730 TRY(96000, 16);
731 TRY(48000, 16);
732 TRY(44100, 16);
733 TRY(22050, 16);
734 TRY(11025, 16);
735
736 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
737 wfx.nChannels ^= 3;
738 TRY(96000, 16);
739 TRY(48000, 16);
740 TRY(44100, 16);
741 TRY(22050, 16);
742 TRY(11025, 16);
743
744 /* first try with same stereo/mono option as source */
745 wfx.nChannels = lpDesc->lpFormat->nChannels;
746 TRY(96000, 8);
747 TRY(48000, 8);
748 TRY(44100, 8);
749 TRY(22050, 8);
750 TRY(11025, 8);
751
752 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
753 wfx.nChannels ^= 3;
754 TRY(96000, 8);
755 TRY(48000, 8);
756 TRY(44100, 8);
757 TRY(22050, 8);
758 TRY(11025, 8);
759 }
760 #undef TRY
761 }
762
763 HeapFree(GetProcessHeap(), 0, wim);
764 WARN("ret = WAVERR_BADFORMAT\n");
765 return WAVERR_BADFORMAT;
766 found:
767 if (dwFlags & WAVE_FORMAT_QUERY) {
768 *lpdwUser = 0L;
769 HeapFree(GetProcessHeap(), 0, wim);
770 } else {
771 *lpdwUser = (DWORD)wim;
772 }
773 TRACE("Ok (stream=%08lx)\n", (DWORD)wim->hAcmStream);
774 return MMSYSERR_NOERROR;
775 error:
776 HeapFree(GetProcessHeap(), 0, wim);
777 if (res==ACMERR_NOTPOSSIBLE) {
778 WARN("ret = WAVERR_BADFORMAT\n");
779 return WAVERR_BADFORMAT;
780 }
781 WARN("ret = MMSYSERR_ERROR\n");
782 return MMSYSERR_ERROR;
783 }
784
785 static DWORD widClose(WAVEMAPDATA* wim)
786 {
787 DWORD ret;
788
789 TRACE("(%p)\n", wim);
790
791 ret = waveInClose(wim->u.in.hInnerWave);
792 if (ret == MMSYSERR_NOERROR) {
793 if (wim->hAcmStream) {
794 ret = acmStreamClose(wim->hAcmStream, 0);
795 }
796 if (ret == MMSYSERR_NOERROR) {
797 HeapFree(GetProcessHeap(), 0, wim);
798 }
799 }
800 return ret;
801 }
802
803 static DWORD widAddBuffer(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
804 {
805 PACMSTREAMHEADER ash;
806 LPWAVEHDR lpWaveHdrSrc;
807
808 TRACE("(%p %p %08lx)\n", wim, lpWaveHdrDst, dwParam2);
809
810 if (!wim->hAcmStream) {
811 return waveInAddBuffer(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
812 }
813
814 lpWaveHdrDst->dwFlags |= WHDR_INQUEUE;
815 ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
816
817 lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
818 return waveInAddBuffer(wim->u.in.hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
819 }
820
821 static DWORD widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
822 {
823 PACMSTREAMHEADER ash;
824 DWORD size;
825 DWORD dwRet;
826 LPWAVEHDR lpWaveHdrSrc;
827
828 TRACE("(%p %p %08lx)\n", wim, lpWaveHdrDst, dwParam2);
829
830 if (!wim->hAcmStream) {
831 return waveInPrepareHeader(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
832 }
833 if (acmStreamSize(wim->hAcmStream, lpWaveHdrDst->dwBufferLength, &size,
834 ACM_STREAMSIZEF_DESTINATION) != MMSYSERR_NOERROR) {
835 WARN("acmStreamSize failed\n");
836 return MMSYSERR_ERROR;
837 }
838
839 ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
840 if (ash == NULL) {
841 WARN("no memory\n");
842 return MMSYSERR_NOMEM;
843 }
844
845 ash->cbStruct = sizeof(*ash);
846 ash->fdwStatus = 0L;
847 ash->dwUser = (DWORD)lpWaveHdrDst;
848 ash->pbSrc = (LPSTR)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
849 ash->cbSrcLength = size;
850 /* ash->cbSrcLengthUsed */
851 ash->dwSrcUser = 0L; /* FIXME ? */
852 ash->pbDst = lpWaveHdrDst->lpData;
853 ash->cbDstLength = lpWaveHdrDst->dwBufferLength;
854 /* ash->cbDstLengthUsed */
855 ash->dwDstUser = lpWaveHdrDst->dwUser; /* FIXME ? */
856 dwRet = acmStreamPrepareHeader(wim->hAcmStream, ash, 0L);
857 if (dwRet != MMSYSERR_NOERROR) {
858 WARN("acmStreamPrepareHeader failed\n");
859 goto errCleanUp;
860 }
861
862 lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
863 lpWaveHdrSrc->lpData = ash->pbSrc;
864 lpWaveHdrSrc->dwBufferLength = size; /* conversion is not done yet */
865 lpWaveHdrSrc->dwFlags = 0;
866 lpWaveHdrSrc->dwLoops = 0;
867 dwRet = waveInPrepareHeader(wim->u.in.hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
868 if (dwRet != MMSYSERR_NOERROR) {
869 WARN("waveInPrepareHeader failed\n");
870 goto errCleanUp;
871 }
872
873 lpWaveHdrDst->reserved = (DWORD)ash;
874 lpWaveHdrDst->dwFlags = WHDR_PREPARED;
875 TRACE("=> (0)\n");
876 return MMSYSERR_NOERROR;
877 errCleanUp:
878 TRACE("=> (%ld)\n", dwRet);
879 HeapFree(GetProcessHeap(), 0, ash);
880 return dwRet;
881 }
882
883 static DWORD widUnprepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
884 {
885 PACMSTREAMHEADER ash;
886 LPWAVEHDR lpWaveHdrSrc;
887 DWORD dwRet1, dwRet2;
888
889 TRACE("(%p %p %08lx)\n", wim, lpWaveHdrDst, dwParam2);
890
891 if (!wim->hAcmStream) {
892 return waveInUnprepareHeader(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
893 }
894 ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
895 dwRet1 = acmStreamUnprepareHeader(wim->hAcmStream, ash, 0L);
896
897 lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
898 dwRet2 = waveInUnprepareHeader(wim->u.in.hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
899
900 HeapFree(GetProcessHeap(), 0, ash);
901
902 lpWaveHdrDst->dwFlags &= ~WHDR_PREPARED;
903 return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
904 }
905
906 static DWORD widGetPosition(WAVEMAPDATA* wim, LPMMTIME lpTime, DWORD dwParam2)
907 {
908 DWORD val;
909
910 TRACE("(%p %p %08lx)\n", wim, lpTime, dwParam2);
911
912 val = waveInGetPosition(wim->u.in.hInnerWave, lpTime, dwParam2);
913 if (lpTime->wType == TIME_BYTES)
914 lpTime->u.cb = MulDiv(lpTime->u.cb, wim->avgSpeedOuter, wim->avgSpeedInner);
915 /* other time types don't require conversion */
916 return val;
917 }
918
919 static DWORD widGetDevCaps(UINT wDevID, WAVEMAPDATA* wim, LPWAVEINCAPSA lpWaveCaps, DWORD dwParam2)
920 {
921 TRACE("(%04x, %p %p %08lx)\n", wDevID, wim, lpWaveCaps, dwParam2);
922
923 /* if opened low driver, forward message */
924 if (WAVEMAP_IsData(wim))
925 return waveInGetDevCapsA((UINT)wim->u.in.hInnerWave, lpWaveCaps, dwParam2);
926 /* else if no drivers, nothing to map so return bad device */
927 if (waveInGetNumDevs() == 0) {
928 WARN("bad device id\n");
929 return MMSYSERR_BADDEVICEID;
930 }
931 /* otherwise, return caps of mapper itself */
932 if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
933 WAVEINCAPSA wic;
934 wic.wMid = 0x00FF;
935 wic.wPid = 0x0001;
936 wic.vDriverVersion = 0x0001;
937 strcpy(wic.szPname, "Wine wave in mapper");
938 wic.dwFormats =
939 WAVE_FORMAT_96M08 | WAVE_FORMAT_96S08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16 |
940 WAVE_FORMAT_48M08 | WAVE_FORMAT_48S08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S16 |
941 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
942 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
943 WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
944 wic.wChannels = 2;
945 memcpy(lpWaveCaps, &wic, min(dwParam2, sizeof(wic)));
946
947 return MMSYSERR_NOERROR;
948 }
949 ERR("This shouldn't happen\n");
950 return MMSYSERR_ERROR;
951 }
952
953 static DWORD widStop(WAVEMAPDATA* wim)
954 {
955 TRACE("(%p)\n", wim);
956
957 return waveInStop(wim->u.in.hInnerWave);
958 }
959
960 static DWORD widStart(WAVEMAPDATA* wim)
961 {
962 TRACE("(%p)\n", wim);
963
964 return waveInStart(wim->u.in.hInnerWave);
965 }
966
967 static DWORD widReset(WAVEMAPDATA* wim)
968 {
969 TRACE("(%p)\n", wim);
970
971 return waveInReset(wim->u.in.hInnerWave);
972 }
973
974 static DWORD widMapperStatus(WAVEMAPDATA* wim, DWORD flags, LPVOID ptr)
975 {
976 UINT id;
977 DWORD ret = MMSYSERR_NOTSUPPORTED;
978
979 TRACE("(%p %08lx %p)\n", wim, flags, ptr);
980
981 switch (flags) {
982 case WAVEIN_MAPPER_STATUS_DEVICE:
983 ret = waveInGetID(wim->u.in.hInnerWave, &id);
984 *(LPDWORD)ptr = id;
985 break;
986 case WAVEIN_MAPPER_STATUS_MAPPED:
987 FIXME("Unsupported yet flag=%ld\n", flags);
988 *(LPDWORD)ptr = 0; /* FIXME ?? */
989 break;
990 case WAVEIN_MAPPER_STATUS_FORMAT:
991 FIXME("Unsupported flag=%ld\n", flags);
992 /* ptr points to a WAVEFORMATEX struct - before or after streaming ? */
993 *(LPDWORD)ptr = 0; /* FIXME ?? */
994 break;
995 default:
996 FIXME("Unsupported flag=%ld\n", flags);
997 *(LPDWORD)ptr = 0;
998 break;
999 }
1000 return ret;
1001 }
1002
1003 /**************************************************************************
1004 * widMessage (MSACM.@)
1005 */
1006 DWORD WINAPI WAVEMAP_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1007 DWORD dwParam1, DWORD dwParam2)
1008 {
1009 TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
1010 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1011
1012 switch (wMsg) {
1013 case DRVM_INIT:
1014 case DRVM_EXIT:
1015 case DRVM_ENABLE:
1016 case DRVM_DISABLE:
1017 /* FIXME: Pretend this is supported */
1018 return 0;
1019
1020 case WIDM_OPEN: return widOpen ((LPDWORD)dwUser, (LPWAVEOPENDESC)dwParam1, dwParam2);
1021 case WIDM_CLOSE: return widClose ((WAVEMAPDATA*)dwUser);
1022
1023 case WIDM_ADDBUFFER: return widAddBuffer ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
1024 case WIDM_PREPARE: return widPrepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
1025 case WIDM_UNPREPARE: return widUnprepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
1026 case WIDM_GETDEVCAPS: return widGetDevCaps (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEINCAPSA)dwParam1, dwParam2);
1027 case WIDM_GETNUMDEVS: return 1;
1028 case WIDM_GETPOS: return widGetPosition ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1, dwParam2);
1029 case WIDM_RESET: return widReset ((WAVEMAPDATA*)dwUser);
1030 case WIDM_START: return widStart ((WAVEMAPDATA*)dwUser);
1031 case WIDM_STOP: return widStop ((WAVEMAPDATA*)dwUser);
1032 case WIDM_MAPPER_STATUS: return widMapperStatus ((WAVEMAPDATA*)dwUser, dwParam1, (LPVOID)dwParam2);
1033 /* known but not supported */
1034 case DRV_QUERYDEVICEINTERFACESIZE:
1035 case DRV_QUERYDEVICEINTERFACE:
1036 return MMSYSERR_NOTSUPPORTED;
1037 default:
1038 FIXME("unknown message %u!\n", wMsg);
1039 }
1040 return MMSYSERR_NOTSUPPORTED;
1041 }
1042
1043 /*======================================================================*
1044 * Driver part *
1045 *======================================================================*/
1046
1047 static struct WINE_WAVEMAP* oss = NULL;
1048
1049 /**************************************************************************
1050 * WAVEMAP_drvOpen [internal]
1051 */
1052 static DWORD WAVEMAP_drvOpen(LPSTR str)
1053 {
1054 TRACE("(%p)\n", str);
1055
1056 if (oss)
1057 return 0;
1058
1059 /* I know, this is ugly, but who cares... */
1060 oss = (struct WINE_WAVEMAP*)1;
1061 return 1;
1062 }
1063
1064 /**************************************************************************
1065 * WAVEMAP_drvClose [internal]
1066 */
1067 static DWORD WAVEMAP_drvClose(DWORD dwDevID)
1068 {
1069 TRACE("(%08lx)\n", dwDevID);
1070
1071 if (oss) {
1072 oss = NULL;
1073 return 1;
1074 }
1075 return 0;
1076 }
1077
1078 /**************************************************************************
1079 * DriverProc (MSACM.@)
1080 */
1081 LONG CALLBACK WAVEMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
1082 DWORD dwParam1, DWORD dwParam2)
1083 {
1084 TRACE("(%08lX, %p, %08lX, %08lX, %08lX)\n",
1085 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1086
1087 switch(wMsg) {
1088 case DRV_LOAD: return 1;
1089 case DRV_FREE: return 1;
1090 case DRV_OPEN: return WAVEMAP_drvOpen((LPSTR)dwParam1);
1091 case DRV_CLOSE: return WAVEMAP_drvClose(dwDevID);
1092 case DRV_ENABLE: return 1;
1093 case DRV_DISABLE: return 1;
1094 case DRV_QUERYCONFIGURE: return 1;
1095 case DRV_CONFIGURE: MessageBoxA(0, "WAVEMAP MultiMedia Driver !", "Wave mapper Driver", MB_OK); return 1;
1096 case DRV_INSTALL: return DRVCNF_RESTART;
1097 case DRV_REMOVE: return DRVCNF_RESTART;
1098 default:
1099 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1100 }
1101 }