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