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