?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed callback parameters (bogus hWave); added acm conversion for
[wine.git] / dlls / winmm / wavemap / wavemap.c
blob37c95df5c085d3e1fe9cf436f7f33c2db8dcef88
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3 * Wine Wave mapper driver
4 *
5 * Copyright 1999,2001 Eric Pouech
6 */
7
8 /* TODOs
9 * + better protection against evilish dwUser parameters
10 * + use asynchronous ACM conversion
11 * + don't use callback functions when none is required in open
12 * + the buffer sizes may not be accurate, so there may be some
13 * remaining bytes in src and dst buffers after ACM conversions...
14 * those should be taken care of...
15 */
16
17 #include <string.h>
18 #include "windef.h"
19 #include "winbase.h"
20 #include "wingdi.h"
21 #include "winuser.h"
22 #include "mmddk.h"
23 #include "msacm.h"
24 #include "debugtools.h"
25
26 DEFAULT_DEBUG_CHANNEL(msacm);
27
28 typedef struct tagWAVEMAPDATA {
29 struct tagWAVEMAPDATA* self;
30 HWAVE hOuterWave;
31 HWAVE hInnerWave;
32 HACMSTREAM hAcmStream;
33 /* needed data to filter callbacks. Only needed when hAcmStream is not 0 */
34 DWORD dwCallback;
35 DWORD dwClientInstance;
36 DWORD dwFlags;
37 } WAVEMAPDATA;
38
39 static BOOL WAVEMAP_IsData(WAVEMAPDATA* wm)
40 {
41 return (!IsBadReadPtr(wm, sizeof(WAVEMAPDATA)) && wm->self == wm);
42 }
43
44 /*======================================================================*
45 * WAVE OUT part *
46 *======================================================================*/
47
48 static void CALLBACK wodCallback(HWAVE hWave, UINT uMsg, DWORD dwInstance,
49 DWORD dwParam1, DWORD dwParam2)
50 {
51 WAVEMAPDATA* wom = (WAVEMAPDATA*)dwInstance;
52
53 TRACE("(0x%x %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
54
55 if (!WAVEMAP_IsData(wom)) {
56 ERR("Bad data\n");
57 return;
58 }
59
60 if (hWave != wom->hInnerWave && uMsg != WOM_OPEN)
61 ERR("Shouldn't happen (%08x %08x)\n", hWave, wom->hInnerWave);
62
63 switch (uMsg) {
64 case WOM_OPEN:
65 case WOM_CLOSE:
66 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
67 break;
68 case WOM_DONE:
69 if (wom->hAcmStream) {
70 LPWAVEHDR lpWaveHdrDst = (LPWAVEHDR)dwParam1;
71 PACMSTREAMHEADER ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrDst - sizeof(ACMSTREAMHEADER));
72 LPWAVEHDR lpWaveHdrSrc = (LPWAVEHDR)ash->dwUser;
73
74 lpWaveHdrSrc->dwFlags &= ~WHDR_INQUEUE;
75 lpWaveHdrSrc->dwFlags |= WHDR_DONE;
76 dwParam1 = (DWORD)lpWaveHdrSrc;
77 }
78 break;
79 default:
80 ERR("Unknown msg %u\n", uMsg);
81 }
82
83 DriverCallback(wom->dwCallback, HIWORD(wom->dwFlags), wom->hOuterWave, uMsg,
84 wom->dwClientInstance, dwParam1, dwParam2);
85 }
86
87 static DWORD wodOpenHelper(WAVEMAPDATA* wom, UINT idx,
88 LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
89 DWORD dwFlags)
90 {
91 DWORD ret;
92
93 /* destination is always PCM, so the formulas below apply */
94 lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
95 lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
96 ret = acmStreamOpen(&wom->hAcmStream, 0, lpDesc->lpFormat, lpwfx, NULL, 0L, 0L,
97 (dwFlags & WAVE_FORMAT_QUERY) ? ACM_STREAMOPENF_QUERY : 0L);
98 if (ret != MMSYSERR_NOERROR)
99 return ret;
100 return waveOutOpen(&wom->hInnerWave, idx, lpwfx, (DWORD)wodCallback,
101 (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
102 }
103
104 static DWORD wodOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
105 {
106 UINT nd = waveOutGetNumDevs();
107 UINT i;
108 WAVEMAPDATA* wom = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
109 WAVEFORMATEX wfx;
110
111 TRACE("(%p %p %08lx\n", lpdwUser, lpDesc, dwFlags);
112
113 if (!wom)
114 return MMSYSERR_NOMEM;
115
116 wom->self = wom;
117 wom->dwCallback = lpDesc->dwCallback;
118 wom->dwFlags = dwFlags;
119 wom->dwClientInstance = lpDesc->dwInstance;
120 wom->hOuterWave = lpDesc->hWave;
121
122 for (i = 0; i < nd; i++) {
123 /* if no ACM stuff is involved, no need to handle callbacks at this
124 * level, this will be done transparently
125 */
126 if (waveOutOpen(&wom->hInnerWave, i, lpDesc->lpFormat, (DWORD)wodCallback,
127 (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION) == MMSYSERR_NOERROR) {
128 wom->hAcmStream = 0;
129 goto found;
130 }
131 }
132
133 wfx.wFormatTag = WAVE_FORMAT_PCM;
134 wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
135 /* try some ACM stuff */
136
137 #define TRY(sps,bps) wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
138 if (wodOpenHelper(wom, i, lpDesc, &wfx, dwFlags) == MMSYSERR_NOERROR) goto found;
139
140 for (i = 0; i < nd; i++) {
141 /* first try with same stereo/mono option as source */
142 wfx.nChannels = lpDesc->lpFormat->nChannels;
143 TRY(44100, 8);
144 TRY(22050, 8);
145 TRY(11025, 8);
146
147 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
148 wfx.nChannels ^= 3;
149 TRY(44100, 8);
150 TRY(22050, 8);
151 TRY(11025, 8);
152 }
153 #undef TRY
154
155 HeapFree(GetProcessHeap(), 0, wom);
156 return MMSYSERR_ALLOCATED;
157 found:
158 if (dwFlags & WAVE_FORMAT_QUERY) {
159 *lpdwUser = 0L;
160 HeapFree(GetProcessHeap(), 0, wom);
161 } else {
162 *lpdwUser = (DWORD)wom;
163 }
164 return MMSYSERR_NOERROR;
165 }
166
167 static DWORD wodClose(WAVEMAPDATA* wom)
168 {
169 DWORD ret = waveOutClose(wom->hInnerWave);
170
171 if (ret == MMSYSERR_NOERROR) {
172 if (wom->hAcmStream) {
173 ret = acmStreamClose(wom->hAcmStream, 0);
174 }
175 if (ret == MMSYSERR_NOERROR) {
176 HeapFree(GetProcessHeap(), 0, wom);
177 }
178 }
179 return ret;
180 }
181
182 static DWORD wodWrite(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
183 {
184 PACMSTREAMHEADER ash;
185 LPWAVEHDR lpWaveHdrDst;
186
187 if (!wom->hAcmStream) {
188 return waveOutWrite(wom->hInnerWave, lpWaveHdrSrc, dwParam2);
189 }
190
191 lpWaveHdrSrc->dwFlags |= WHDR_INQUEUE;
192 ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
193 if (acmStreamConvert(wom->hAcmStream, ash, 0L) != MMSYSERR_NOERROR)
194 return MMSYSERR_ERROR;
195
196 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
197 lpWaveHdrDst->dwBufferLength = ash->cbDstLengthUsed;
198 return waveOutWrite(wom->hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
199 }
200
201 static DWORD wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
202 {
203 PACMSTREAMHEADER ash;
204 DWORD size;
205 DWORD dwRet;
206 LPWAVEHDR lpWaveHdrDst;
207
208 if (!wom->hAcmStream) {
209 return waveOutPrepareHeader(wom->hInnerWave, lpWaveHdrSrc, dwParam2);
210 }
211 if (acmStreamSize(wom->hAcmStream, lpWaveHdrSrc->dwBufferLength, &size, ACM_STREAMSIZEF_SOURCE) != MMSYSERR_NOERROR)
212 return MMSYSERR_ERROR;
213
214 ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
215 if (ash == NULL)
216 return MMSYSERR_NOMEM;
217
218 ash->cbStruct = sizeof(*ash);
219 ash->fdwStatus = 0L;
220 ash->dwUser = (DWORD)lpWaveHdrSrc;
221 ash->pbSrc = lpWaveHdrSrc->lpData;
222 ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
223 /* ash->cbSrcLengthUsed */
224 ash->dwSrcUser = lpWaveHdrSrc->dwUser; /* FIXME ? */
225 ash->pbDst = (LPSTR)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
226 ash->cbDstLength = size;
227 /* ash->cbDstLengthUsed */
228 ash->dwDstUser = 0; /* FIXME ? */
229 dwRet = acmStreamPrepareHeader(wom->hAcmStream, ash, 0L);
230 if (dwRet != MMSYSERR_NOERROR)
231 goto errCleanUp;
232
233 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
234 lpWaveHdrDst->lpData = ash->pbDst;
235 lpWaveHdrDst->dwBufferLength = size; /* conversion is not done yet */
236 lpWaveHdrDst->dwFlags = 0;
237 lpWaveHdrDst->dwLoops = 0;
238 dwRet = waveOutPrepareHeader(wom->hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
239 if (dwRet != MMSYSERR_NOERROR)
240 goto errCleanUp;
241
242 lpWaveHdrSrc->reserved = (DWORD)ash;
243 lpWaveHdrSrc->dwFlags = WHDR_PREPARED;
244 TRACE("=> (0)\n");
245 return MMSYSERR_NOERROR;
246 errCleanUp:
247 TRACE("=> (%ld)\n", dwRet);
248 HeapFree(GetProcessHeap(), 0, ash);
249 return dwRet;
250 }
251
252 static DWORD wodUnprepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
253 {
254 PACMSTREAMHEADER ash;
255 LPWAVEHDR lpWaveHdrDst;
256 DWORD dwRet1, dwRet2;
257
258 if (!wom->hAcmStream) {
259 return waveOutUnprepareHeader(wom->hInnerWave, lpWaveHdrSrc, dwParam2);
260 }
261 ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
262 dwRet1 = acmStreamUnprepareHeader(wom->hAcmStream, ash, 0L);
263
264 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
265 dwRet2 = waveOutUnprepareHeader(wom->hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
266
267 HeapFree(GetProcessHeap(), 0, ash);
268
269 lpWaveHdrSrc->dwFlags &= ~WHDR_PREPARED;
270 return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
271 }
272
273 static DWORD wodGetPosition(WAVEMAPDATA* wom, LPMMTIME lpTime, DWORD dwParam2)
274 {
275 if (wom->hAcmStream)
276 FIXME("No position conversion done for PCM => non-PCM, returning PCM position\n");
277 return waveOutGetPosition(wom->hInnerWave, lpTime, dwParam2);
278 }
279
280 static DWORD wodGetDevCaps(UINT wDevID, WAVEMAPDATA* wom, LPWAVEOUTCAPSA lpWaveCaps, DWORD dwParam2)
281 {
282 /* if opened low driver, forward message */
283 if (WAVEMAP_IsData(wom))
284 return waveOutGetDevCapsA(wom->hInnerWave, lpWaveCaps, dwParam2);
285 /* otherwise, return caps of mapper itself */
286 if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
287 lpWaveCaps->wMid = 0x00FF;
288 lpWaveCaps->wPid = 0x0001;
289 lpWaveCaps->vDriverVersion = 0x0100;
290 strcpy(lpWaveCaps->szPname, "Wine wave out mapper");
291 lpWaveCaps->dwFormats =
292 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
293 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
294 WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
295 lpWaveCaps->wChannels = 2;
296 lpWaveCaps->dwSupport = WAVECAPS_VOLUME | WAVECAPS_LRVOLUME;
297
298 return MMSYSERR_NOERROR;
299 }
300 ERR("This shouldn't happen\n");
301 return MMSYSERR_ERROR;
302 }
303
304 static DWORD wodGetVolume(UINT wDevID, WAVEMAPDATA* wom, LPDWORD lpVol)
305 {
306 if (WAVEMAP_IsData(wom))
307 return waveOutGetVolume(wom->hInnerWave, lpVol);
308 return MMSYSERR_NOERROR;
309 }
310
311 static DWORD wodSetVolume(UINT wDevID, WAVEMAPDATA* wom, DWORD vol)
312 {
313 if (WAVEMAP_IsData(wom))
314 return waveOutSetVolume(wom->hInnerWave, vol);
315 return MMSYSERR_NOERROR;
316 }
317
318 static DWORD wodPause(WAVEMAPDATA* wom)
319 {
320 return waveOutPause(wom->hInnerWave);
321 }
322
323 static DWORD wodRestart(WAVEMAPDATA* wom)
324 {
325 return waveOutRestart(wom->hInnerWave);
326 }
327
328 static DWORD wodReset(WAVEMAPDATA* wom)
329 {
330 return waveOutReset(wom->hInnerWave);
331 }
332
333 static DWORD wodBreakLoop(WAVEMAPDATA* wom)
334 {
335 return waveOutBreakLoop(wom->hInnerWave);
336 }
337
338 static DWORD wodMapperStatus(WAVEMAPDATA* wom, DWORD flags, LPVOID ptr)
339 {
340 UINT id;
341 DWORD ret = MMSYSERR_NOTSUPPORTED;
342
343 switch (flags) {
344 case WAVEOUT_MAPPER_STATUS_DEVICE:
345 ret = waveOutGetID(wom->hInnerWave, &id);
346 *(LPDWORD)ptr = id;
347 break;
348 case WAVEOUT_MAPPER_STATUS_MAPPED:
349 FIXME("Unsupported flag=%ld\n", flags);
350 *(LPDWORD)ptr = 0; /* FIXME ?? */
351 break;
352 case WAVEOUT_MAPPER_STATUS_FORMAT:
353 FIXME("Unsupported flag=%ld\n", flags);
354 /* ptr points to a WAVEFORMATEX struct - before or after streaming ? */
355 *(LPDWORD)ptr = 0;
356 break;
357 default:
358 FIXME("Unsupported flag=%ld\n", flags);
359 *(LPDWORD)ptr = 0;
360 break;
361 }
362 return ret;
363 }
364
365 /**************************************************************************
366 * WAVEMAP_wodMessage [sample driver]
367 */
368 DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
369 DWORD dwParam1, DWORD dwParam2)
370 {
371 TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
372 wDevID, wMsg, dwUser, dwParam1, dwParam2);
373
374 switch (wMsg) {
375 case DRVM_INIT:
376 case DRVM_EXIT:
377 case DRVM_ENABLE:
378 case DRVM_DISABLE:
379 /* FIXME: Pretend this is supported */
380 return 0;
381 case WODM_OPEN: return wodOpen ((LPDWORD)dwUser, (LPWAVEOPENDESC)dwParam1,dwParam2);
382 case WODM_CLOSE: return wodClose ((WAVEMAPDATA*)dwUser);
383 case WODM_WRITE: return wodWrite ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
384 case WODM_PAUSE: return wodPause ((WAVEMAPDATA*)dwUser);
385 case WODM_GETPOS: return wodGetPosition ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1, dwParam2);
386 case WODM_BREAKLOOP: return wodBreakLoop ((WAVEMAPDATA*)dwUser);
387 case WODM_PREPARE: return wodPrepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
388 case WODM_UNPREPARE: return wodUnprepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
389 case WODM_GETDEVCAPS: return wodGetDevCaps (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEOUTCAPSA)dwParam1,dwParam2);
390 case WODM_GETNUMDEVS: return 1;
391 case WODM_GETPITCH: return MMSYSERR_NOTSUPPORTED;
392 case WODM_SETPITCH: return MMSYSERR_NOTSUPPORTED;
393 case WODM_GETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
394 case WODM_SETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
395 case WODM_GETVOLUME: return wodGetVolume (wDevID, (WAVEMAPDATA*)dwUser, (LPDWORD)dwParam1);
396 case WODM_SETVOLUME: return wodSetVolume (wDevID, (WAVEMAPDATA*)dwUser, dwParam1);
397 case WODM_RESTART: return wodRestart ((WAVEMAPDATA*)dwUser);
398 case WODM_RESET: return wodReset ((WAVEMAPDATA*)dwUser);
399 case WODM_MAPPER_STATUS: return wodMapperStatus ((WAVEMAPDATA*)dwUser, dwParam1, (LPVOID)dwParam2);
400 default:
401 FIXME("unknown message %d!\n", wMsg);
402 }
403 return MMSYSERR_NOTSUPPORTED;
404 }
405
406 /*======================================================================*
407 * WAVE IN part *
408 *======================================================================*/
409
410 static void CALLBACK widCallback(HWAVE hWave, UINT uMsg, DWORD dwInstance,
411 DWORD dwParam1, DWORD dwParam2)
412 {
413 WAVEMAPDATA* wim = (WAVEMAPDATA*)dwInstance;
414
415 TRACE("(0x%x %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
416
417 if (!WAVEMAP_IsData(wim)) {
418 ERR("Bad date\n");
419 return;
420 }
421
422 if (hWave != wim->hInnerWave && uMsg != WIM_OPEN)
423 ERR("Shouldn't happen (%08x %08x)\n", hWave, wim->hInnerWave);
424
425 switch (uMsg) {
426 case WIM_OPEN:
427 case WIM_CLOSE:
428 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
429 break;
430 case WIM_DATA:
431 if (wim->hAcmStream) {
432 LPWAVEHDR lpWaveHdrSrc = (LPWAVEHDR)dwParam1;
433 PACMSTREAMHEADER ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrSrc - sizeof(ACMSTREAMHEADER));
434 LPWAVEHDR lpWaveHdrDst = (LPWAVEHDR)ash->dwUser;
435
436 /* convert data just gotten from waveIn into requested format */
437 if (acmStreamConvert(wim->hAcmStream, ash, 0L) != MMSYSERR_NOERROR) {
438 ERR("ACM conversion failed\n");
439 return;
440 } else {
441 TRACE("Converted %ld bytes into %ld\n", ash->cbSrcLengthUsed, ash->cbDstLengthUsed);
442 }
443 /* and setup the wavehdr to return accordingly */
444 lpWaveHdrDst->dwFlags &= ~WHDR_INQUEUE;
445 lpWaveHdrDst->dwFlags |= WHDR_DONE;
446 lpWaveHdrDst->dwBytesRecorded = ash->cbDstLengthUsed;
447 dwParam1 = (DWORD)lpWaveHdrDst;
448 }
449 break;
450 default:
451 ERR("Unknown msg %u\n", uMsg);
452 }
453
454 DriverCallback(wim->dwCallback, HIWORD(wim->dwFlags), wim->hOuterWave, uMsg,
455 wim->dwClientInstance, dwParam1, dwParam2);
456 }
457
458 static DWORD widOpenHelper(WAVEMAPDATA* wim, UINT idx,
459 LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
460 DWORD dwFlags)
461 {
462 DWORD ret;
463
464 /* source is always PCM, so the formulas below apply */
465 lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
466 lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
467 ret = acmStreamOpen(&wim->hAcmStream, 0, lpwfx, lpDesc->lpFormat, NULL, 0L, 0L,
468 (dwFlags & WAVE_FORMAT_QUERY) ? ACM_STREAMOPENF_QUERY : 0L);
469 if (ret != MMSYSERR_NOERROR)
470 return ret;
471 return waveInOpen(&wim->hInnerWave, idx, lpwfx, (DWORD)widCallback,
472 (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
473 }
474
475 static DWORD widOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
476 {
477 UINT nd = waveInGetNumDevs();
478 UINT i;
479 WAVEMAPDATA* wim = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
480 WAVEFORMATEX wfx;
481
482 TRACE("(%p %p %08lx\n", lpdwUser, lpDesc, dwFlags);
483
484 if (!wim)
485 return MMSYSERR_NOMEM;
486
487 wim->self = wim;
488 wim->dwCallback = lpDesc->dwCallback;
489 wim->dwFlags = dwFlags;
490 wim->dwClientInstance = lpDesc->dwInstance;
491 wim->hOuterWave = lpDesc->hWave;
492
493 for (i = 0; i < nd; i++) {
494 if (waveInOpen(&wim->hInnerWave, i, lpDesc->lpFormat, (DWORD)widCallback,
495 (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION) == MMSYSERR_NOERROR) {
496 wim->hAcmStream = 0;
497 goto found;
498 }
499 }
500 wfx.wFormatTag = WAVE_FORMAT_PCM;
501 wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
502 /* try some ACM stuff */
503
504 #define TRY(sps,bps) wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
505 if (widOpenHelper(wim, i, lpDesc, &wfx, dwFlags) == MMSYSERR_NOERROR) goto found;
506
507 for (i = 0; i < nd; i++) {
508 /* first try with same stereo/mono option as source */
509 wfx.nChannels = lpDesc->lpFormat->nChannels;
510 TRY(44100, 8);
511 TRY(22050, 8);
512 TRY(11025, 8);
513
514 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
515 wfx.nChannels ^= 3;
516 TRY(44100, 8);
517 TRY(22050, 8);
518 TRY(11025, 8);
519 }
520 #undef TRY
521
522 HeapFree(GetProcessHeap(), 0, wim);
523 return MMSYSERR_ALLOCATED;
524 found:
525 if (dwFlags & WAVE_FORMAT_QUERY) {
526 *lpdwUser = 0L;
527 HeapFree(GetProcessHeap(), 0, wim);
528 } else {
529 *lpdwUser = (DWORD)wim;
530 }
531 return MMSYSERR_NOERROR;
532 }
533
534 static DWORD widClose(WAVEMAPDATA* wim)
535 {
536 DWORD ret = waveInClose(wim->hInnerWave);
537
538 if (ret == MMSYSERR_NOERROR) {
539 if (wim->hAcmStream) {
540 ret = acmStreamClose(wim->hAcmStream, 0);
541 }
542 if (ret == MMSYSERR_NOERROR) {
543 HeapFree(GetProcessHeap(), 0, wim);
544 }
545 }
546 return ret;
547 }
548
549 static DWORD widAddBuffer(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
550 {
551 PACMSTREAMHEADER ash;
552 LPWAVEHDR lpWaveHdrSrc;
553
554 if (!wim->hAcmStream) {
555 return waveInAddBuffer(wim->hInnerWave, lpWaveHdrDst, dwParam2);
556 }
557
558 lpWaveHdrDst->dwFlags |= WHDR_INQUEUE;
559 ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
560
561 lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
562 return waveInAddBuffer(wim->hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
563 }
564
565 static DWORD widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
566 {
567 PACMSTREAMHEADER ash;
568 DWORD size;
569 DWORD dwRet;
570 LPWAVEHDR lpWaveHdrSrc;
571
572 if (!wim->hAcmStream) {
573 return waveInPrepareHeader(wim->hInnerWave, lpWaveHdrDst, dwParam2);
574 }
575 if (acmStreamSize(wim->hAcmStream, lpWaveHdrDst->dwBufferLength, &size,
576 ACM_STREAMSIZEF_DESTINATION) != MMSYSERR_NOERROR)
577 return MMSYSERR_ERROR;
578
579 ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
580 if (ash == NULL)
581 return MMSYSERR_NOMEM;
582
583 ash->cbStruct = sizeof(*ash);
584 ash->fdwStatus = 0L;
585 ash->dwUser = (DWORD)lpWaveHdrDst;
586 ash->pbSrc = (LPSTR)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
587 ash->cbSrcLength = size;
588 /* ash->cbSrcLengthUsed */
589 ash->dwSrcUser = 0L; /* FIXME ? */
590 ash->pbDst = lpWaveHdrDst->lpData;
591 ash->cbDstLength = lpWaveHdrDst->dwBufferLength;
592 /* ash->cbDstLengthUsed */
593 ash->dwDstUser = lpWaveHdrDst->dwUser; /* FIXME ? */
594 dwRet = acmStreamPrepareHeader(wim->hAcmStream, ash, 0L);
595 if (dwRet != MMSYSERR_NOERROR)
596 goto errCleanUp;
597
598 lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
599 lpWaveHdrSrc->lpData = ash->pbSrc;
600 lpWaveHdrSrc->dwBufferLength = size; /* conversion is not done yet */
601 lpWaveHdrSrc->dwFlags = 0;
602 lpWaveHdrSrc->dwLoops = 0;
603 dwRet = waveInPrepareHeader(wim->hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
604 if (dwRet != MMSYSERR_NOERROR)
605 goto errCleanUp;
606
607 lpWaveHdrDst->reserved = (DWORD)ash;
608 lpWaveHdrDst->dwFlags = WHDR_PREPARED;
609 TRACE("=> (0)\n");
610 return MMSYSERR_NOERROR;
611 errCleanUp:
612 TRACE("=> (%ld)\n", dwRet);
613 HeapFree(GetProcessHeap(), 0, ash);
614 return dwRet;
615 }
616
617 static DWORD widUnprepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
618 {
619 PACMSTREAMHEADER ash;
620 LPWAVEHDR lpWaveHdrSrc;
621 DWORD dwRet1, dwRet2;
622
623 if (!wim->hAcmStream) {
624 return waveInUnprepareHeader(wim->hInnerWave, lpWaveHdrDst, dwParam2);
625 }
626 ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
627 dwRet1 = acmStreamUnprepareHeader(wim->hAcmStream, ash, 0L);
628
629 lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
630 dwRet2 = waveInUnprepareHeader(wim->hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
631
632 HeapFree(GetProcessHeap(), 0, ash);
633
634 lpWaveHdrDst->dwFlags &= ~WHDR_PREPARED;
635 return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
636 }
637
638 static DWORD widGetPosition(WAVEMAPDATA* wim, LPMMTIME lpTime, DWORD dwParam2)
639 {
640 if (wim->hAcmStream)
641 FIXME("No position conversion done for PCM => non-PCM, returning PCM position\n");
642 return waveInGetPosition(wim->hInnerWave, lpTime, dwParam2);
643 }
644
645 static DWORD widGetDevCaps(UINT wDevID, WAVEMAPDATA* wim, LPWAVEINCAPSA lpWaveCaps, DWORD dwParam2)
646 {
647 /* if opened low driver, forward message */
648 if (WAVEMAP_IsData(wim))
649 return waveInGetDevCapsA(wim->hInnerWave, lpWaveCaps, dwParam2);
650 /* otherwise, return caps of mapper itself */
651 if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
652 lpWaveCaps->wMid = 0x00FF;
653 lpWaveCaps->wPid = 0x0001;
654 lpWaveCaps->vDriverVersion = 0x0001;
655 strcpy(lpWaveCaps->szPname, "Wine wave in mapper");
656 lpWaveCaps->dwFormats =
657 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
658 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
659 WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
660 lpWaveCaps->wChannels = 2;
661 return MMSYSERR_NOERROR;
662 }
663 ERR("This shouldn't happen\n");
664 return MMSYSERR_ERROR;
665 }
666
667 static DWORD widStop(WAVEMAPDATA* wim)
668 {
669 return waveInStop(wim->hInnerWave);
670 }
671
672 static DWORD widStart(WAVEMAPDATA* wim)
673 {
674 return waveInStart(wim->hInnerWave);
675 }
676
677 static DWORD widReset(WAVEMAPDATA* wim)
678 {
679 return waveInReset(wim->hInnerWave);
680 }
681
682 static DWORD widMapperStatus(WAVEMAPDATA* wim, DWORD flags, LPVOID ptr)
683 {
684 UINT id;
685 DWORD ret = MMSYSERR_NOTSUPPORTED;
686
687 switch (flags) {
688 case WAVEIN_MAPPER_STATUS_DEVICE:
689 ret = waveInGetID(wim->hInnerWave, &id);
690 *(LPDWORD)ptr = id;
691 break;
692 case WAVEIN_MAPPER_STATUS_MAPPED:
693 FIXME("Unsupported yet flag=%ld\n", flags);
694 *(LPDWORD)ptr = 0; /* FIXME ?? */
695 break;
696 case WAVEIN_MAPPER_STATUS_FORMAT:
697 FIXME("Unsupported flag=%ld\n", flags);
698 /* ptr points to a WAVEFORMATEX struct - before or after streaming ? */
699 *(LPDWORD)ptr = 0; /* FIXME ?? */
700 break;
701 default:
702 FIXME("Unsupported flag=%ld\n", flags);
703 *(LPDWORD)ptr = 0;
704 break;
705 }
706 return ret;
707 }
708
709 /**************************************************************************
710 * WAVEMAP_widMessage [sample driver]
711 */
712 DWORD WINAPI WAVEMAP_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
713 DWORD dwParam1, DWORD dwParam2)
714 {
715 TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
716 wDevID, wMsg, dwUser, dwParam1, dwParam2);
717
718 switch (wMsg) {
719 case DRVM_INIT:
720 case DRVM_EXIT:
721 case DRVM_ENABLE:
722 case DRVM_DISABLE:
723 /* FIXME: Pretend this is supported */
724 return 0;
725
726 case WIDM_OPEN: return widOpen ((LPDWORD)dwUser, (LPWAVEOPENDESC)dwParam1, dwParam2);
727 case WIDM_CLOSE: return widClose ((WAVEMAPDATA*)dwUser);
728
729 case WIDM_ADDBUFFER: return widAddBuffer ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
730 case WIDM_PREPARE: return widPrepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
731 case WIDM_UNPREPARE: return widUnprepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
732 case WIDM_GETDEVCAPS: return widGetDevCaps (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEINCAPSA)dwParam1, dwParam2);
733 case WIDM_GETNUMDEVS: return 1;
734 case WIDM_GETPOS: return widGetPosition ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1, dwParam2);
735 case WIDM_RESET: return widReset ((WAVEMAPDATA*)dwUser);
736 case WIDM_START: return widStart ((WAVEMAPDATA*)dwUser);
737 case WIDM_STOP: return widStop ((WAVEMAPDATA*)dwUser);
738 case WIDM_MAPPER_STATUS: return widMapperStatus ((WAVEMAPDATA*)dwUser, dwParam1, (LPVOID)dwParam2);
739 default:
740 FIXME("unknown message %u!\n", wMsg);
741 }
742 return MMSYSERR_NOTSUPPORTED;
743 }
744
745 /*======================================================================*
746 * Driver part *
747 *======================================================================*/
748
749 static struct WINE_WAVEMAP* oss = NULL;
750
751 /**************************************************************************
752 * WAVEMAP_drvOpen [internal]
753 */
754 static DWORD WAVEMAP_drvOpen(LPSTR str)
755 {
756 if (oss)
757 return 0;
758
759 /* I know, this is ugly, but who cares... */
760 oss = (struct WINE_WAVEMAP*)1;
761 return 1;
762 }
763
764 /**************************************************************************
765 * WAVEMAP_drvClose [internal]
766 */
767 static DWORD WAVEMAP_drvClose(DWORD dwDevID)
768 {
769 if (oss) {
770 oss = NULL;
771 return 1;
772 }
773 return 0;
774 }
775
776 /**************************************************************************
777 * WAVEMAP_DriverProc [internal]
778 */
779 LONG CALLBACK WAVEMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
780 DWORD dwParam1, DWORD dwParam2)
781 {
782 TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",
783 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
784
785 switch(wMsg) {
786 case DRV_LOAD: return 1;
787 case DRV_FREE: return 1;
788 case DRV_OPEN: return WAVEMAP_drvOpen((LPSTR)dwParam1);
789 case DRV_CLOSE: return WAVEMAP_drvClose(dwDevID);
790 case DRV_ENABLE: return 1;
791 case DRV_DISABLE: return 1;
792 case DRV_QUERYCONFIGURE: return 1;
793 case DRV_CONFIGURE: MessageBoxA(0, "WAVEMAP MultiMedia Driver !", "OSS Driver", MB_OK); return 1;
794 case DRV_INSTALL: return DRVCNF_RESTART;
795 case DRV_REMOVE: return DRVCNF_RESTART;
796 default:
797 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
798 }
799 }
800
801
Windows API implementation