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