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