source: trunk/src/winmm/wavemap/msacm32.cpp

Last change on this file was 2472, checked in by sandervl, 26 years ago

JW: Updated to Wine level 20000109 + corrected compile
File size: 18.5 KB
Line 
1/* -*- tab-width: 8; c-basic-offset: 4 -*- */
2/*
3 * Wine Wave mapper driver
4 *
5 * Copyright 1999 Eric Pouech
6 */
7
8/* TODOs
9 * + implement wavein as waveout has been implemented
10 * + better protection against evilish dwUser parameters
11 * + use asynchronous ACM conversion
12 */
13
14#include <os2win.h>
15#include <string.h>
16#include "winuser.h"
17#include "driver.h"
18#include "mmddk.h"
19#include "msacm.h"
20#include "debugtools.h"
21
22DEFAULT_DEBUG_CHANNEL(msacm)
23
24typedef struct tagWAVEMAPDATA {
25 struct tagWAVEMAPDATA* self;
26 HWAVE hWave;
27 HACMSTREAM hAcmStream;
28 /* needed data to filter callbacks. Only needed when hAcmStream is not 0 */
29 DWORD dwCallback;
30 DWORD dwClientInstance;
31 DWORD dwFlags;
32 MMRESULT (WINAPI *acmStreamOpen)(LPHACMSTREAM, HACMDRIVER, LPWAVEFORMATEX, LPWAVEFORMATEX, LPWAVEFILTER, DWORD, DWORD, DWORD);
33 MMRESULT (WINAPI *acmStreamClose)(HACMSTREAM, DWORD);
34 MMRESULT (WINAPI *acmStreamSize)(HACMSTREAM, DWORD, LPDWORD, DWORD);
35 MMRESULT (WINAPI *acmStreamConvert)(HACMSTREAM, PACMSTREAMHEADER, DWORD);
36 MMRESULT (WINAPI *acmStreamPrepareHeader)(HACMSTREAM, PACMSTREAMHEADER, DWORD);
37 MMRESULT (WINAPI *acmStreamUnprepareHeader)(HACMSTREAM, PACMSTREAMHEADER, DWORD);
38} WAVEMAPDATA;
39
40static BOOL WAVEMAP_IsData(WAVEMAPDATA* wm)
41{
42 return (!IsBadReadPtr(wm, sizeof(WAVEMAPDATA)) && wm->self == wm);
43}
44
45/*======================================================================*
46 * WAVE OUT part *
47 *======================================================================*/
48
49static void CALLBACK WAVEMAP_DstCallback(HDRVR hDev, UINT uMsg, DWORD dwInstance,
50 DWORD dwParam1, DWORD dwParam2)
51{
52 WAVEMAPDATA* wom = (WAVEMAPDATA*)dwInstance;
53
54 TRACE("(0x%x %u %ld %lx %lx);\n", hDev, uMsg, dwInstance, dwParam1, dwParam2);
55
56 switch (uMsg) {
57 case WOM_OPEN:
58 case WOM_CLOSE:
59 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
60 break;
61 case WOM_DONE:
62 {
63 LPWAVEHDR lpWaveHdrDst = (LPWAVEHDR)dwParam1;
64 PACMSTREAMHEADER ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrDst - sizeof(ACMSTREAMHEADER));
65 LPWAVEHDR lpWaveHdrSrc = (LPWAVEHDR)ash->dwUser;
66
67 lpWaveHdrSrc->dwFlags &= ~WHDR_INQUEUE;
68 lpWaveHdrSrc->dwFlags |= WHDR_DONE;
69 dwParam1 = (DWORD)lpWaveHdrSrc;
70 }
71 break;
72 default:
73 ERR("Unknown msg %u\n", uMsg);
74 }
75
76 DriverCallback(wom->dwCallback, HIWORD(wom->dwFlags), hDev, uMsg,
77 wom->dwClientInstance, dwParam1, dwParam2);
78}
79
80static DWORD wodOpenHelper(WAVEMAPDATA* wom, UINT idx,
81 LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
82 DWORD dwFlags)
83{
84 DWORD ret;
85
86 /* destination is always PCM, so the formulas below apply */
87 lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
88 lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
89 ret = wom->acmStreamOpen(&wom->hAcmStream, 0, lpDesc->lpFormat, lpwfx, NULL, 0L, 0L,
90 (dwFlags & WAVE_FORMAT_QUERY) ? ACM_STREAMOPENF_QUERY : 0L);
91 if (ret != MMSYSERR_NOERROR)
92 return ret;
93 return waveOutOpen(&wom->hWave, idx, lpwfx, (DWORD)WAVEMAP_DstCallback,
94 (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
95}
96
97static DWORD wodOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
98{
99 UINT nd = waveOutGetNumDevs();
100 UINT i;
101 WAVEMAPDATA* wom = (WAVEMAPDATA*)HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
102 WAVEFORMATEX wfx;
103
104 TRACE("(%p %p %08lx\n", lpdwUser, lpDesc, dwFlags);
105
106 if (!wom)
107 return MMSYSERR_NOMEM;
108
109 wom->self = wom;
110
111 for (i = 0; i < nd; i++) {
112 /* if no ACM stuff is involved, no need to handle callbacks at this
113 * level, this will be done transparently
114 */
115 if (waveOutOpen(&wom->hWave, i, lpDesc->lpFormat, lpDesc->dwCallback,
116 lpDesc->dwInstance, dwFlags) == MMSYSERR_NOERROR) {
117 wom->hAcmStream = 0;
118 goto found;
119 }
120 }
121
122 /* temporary hack until real builtin dll loading is available */
123 do {
124 HMODULE hModule = LoadLibraryA("msacm32.dll");
125
126 *(VOID **)wom->acmStreamOpen = (void*)GetProcAddress(hModule, "acmStreamOpen");
127 *(VOID **)wom->acmStreamClose = (void*)GetProcAddress(hModule, "acmStreamClose");
128 *(VOID **)wom->acmStreamSize = (void*)GetProcAddress(hModule, "acmStreamSize");
129 *(VOID **)wom->acmStreamConvert = (void*)GetProcAddress(hModule, "acmStreamConvert");
130 *(VOID **)wom->acmStreamPrepareHeader = (void*)GetProcAddress(hModule, "acmStreamPrepareHeader");
131 *(VOID **)wom->acmStreamUnprepareHeader = (void*)GetProcAddress(hModule, "acmStreamUnprepareHeader");
132 } while (0);
133
134 wfx.wFormatTag = WAVE_FORMAT_PCM;
135 wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
136 /* try some ACM stuff */
137
138 wom->dwCallback = lpDesc->dwCallback;
139 wom->dwFlags = dwFlags;
140 wom->dwClientInstance = lpDesc->dwInstance;
141
142#define TRY(sps,bps) wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
143 if (wodOpenHelper(wom, i, lpDesc, &wfx, dwFlags) == MMSYSERR_NOERROR) goto found;
144
145 for (i = 0; i < nd; i++) {
146 /* first try with same stereo/mono option as source */
147 wfx.nChannels = lpDesc->lpFormat->nChannels;
148 TRY(44100, 8);
149 TRY(22050, 8);
150 TRY(11025, 8);
151
152 /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way around) */
153 wfx.nChannels ^= 3;
154 TRY(44100, 8);
155 TRY(22050, 8);
156 TRY(11025, 8);
157 }
158#undef TRY
159
160 HeapFree(GetProcessHeap(), 0, wom);
161 return MMSYSERR_ALLOCATED;
162found:
163 if (dwFlags & WAVE_FORMAT_QUERY) {
164 lpDesc->hWave = 0;
165 *lpdwUser = 0L;
166 HeapFree(GetProcessHeap(), 0, wom);
167 } else {
168 lpDesc->hWave = wom->hWave;
169 *lpdwUser = (DWORD)wom;
170 }
171 return MMSYSERR_NOERROR;
172}
173
174static DWORD wodClose(WAVEMAPDATA* wom)
175{
176 DWORD ret = waveOutClose(wom->hWave);
177
178 if (ret == MMSYSERR_NOERROR) {
179 if (wom->hAcmStream) {
180 ret = wom->acmStreamClose(wom->hAcmStream, 0);
181 }
182 if (ret == MMSYSERR_NOERROR) {
183 HeapFree(GetProcessHeap(), 0, wom);
184 }
185 }
186 return ret;
187}
188
189static DWORD wodWrite(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
190{
191 PACMSTREAMHEADER ash;
192 LPWAVEHDR lpWaveHdrDst;
193
194 if (!wom->hAcmStream) {
195 return waveOutWrite(wom->hWave, lpWaveHdrSrc, dwParam2);
196 }
197
198 lpWaveHdrSrc->dwFlags |= WHDR_INQUEUE;
199 ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
200 if (wom->acmStreamConvert(wom->hAcmStream, ash, 0L) != MMSYSERR_NOERROR)
201 return MMSYSERR_ERROR;
202
203 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
204 lpWaveHdrDst->dwBufferLength = ash->cbDstLengthUsed;
205 return waveOutWrite(wom->hWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
206}
207
208static DWORD wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
209{
210 PACMSTREAMHEADER ash;
211 DWORD size;
212 DWORD dwRet;
213 LPWAVEHDR lpWaveHdrDst;
214
215 if (!wom->hAcmStream) {
216 return waveOutPrepareHeader(wom->hWave, lpWaveHdrSrc, dwParam2);
217 }
218 if (wom->acmStreamSize(wom->hAcmStream, lpWaveHdrSrc->dwBufferLength, &size, ACM_STREAMSIZEF_SOURCE) != MMSYSERR_NOERROR)
219 return MMSYSERR_ERROR;
220
221 ash = (_ACMSTREAMHEADER*)HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
222 if (ash == NULL)
223 return MMSYSERR_NOMEM;
224
225 ash->cbStruct = sizeof(*ash);
226 ash->fdwStatus = 0L;
227 ash->dwUser = (DWORD)lpWaveHdrSrc;
228 ash->pbSrc = (BYTE*)lpWaveHdrSrc->lpData;
229 ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
230 /* ash->cbSrcLengthUsed */
231 ash->dwSrcUser = lpWaveHdrSrc->dwUser; /* FIXME ? */
232 ash->pbDst = (BYTE*)((LPSTR)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR));
233 ash->cbDstLength = size;
234 /* ash->cbDstLengthUsed */
235 ash->dwDstUser = 0; /* FIXME ? */
236 dwRet = wom->acmStreamPrepareHeader(wom->hAcmStream, ash, 0L);
237 if (dwRet != MMSYSERR_NOERROR)
238 goto errCleanUp;
239
240 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
241 lpWaveHdrDst->lpData = (CHAR*)ash->pbDst;
242 lpWaveHdrDst->dwBufferLength = size; /* conversion is not done yet */
243 lpWaveHdrDst->dwFlags = 0;
244 lpWaveHdrDst->dwLoops = 0;
245 dwRet = waveOutPrepareHeader(wom->hWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
246 if (dwRet != MMSYSERR_NOERROR)
247 goto errCleanUp;
248
249 lpWaveHdrSrc->reserved = (DWORD)ash;
250 lpWaveHdrSrc->dwFlags = WHDR_PREPARED;
251 TRACE("=> (0)\n");
252 return MMSYSERR_NOERROR;
253errCleanUp:
254 TRACE("=> (%ld)\n", dwRet);
255 HeapFree(GetProcessHeap(), 0, ash);
256 return dwRet;
257}
258
259static DWORD wodUnprepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
260{
261 PACMSTREAMHEADER ash;
262 LPWAVEHDR lpWaveHdrDst;
263 DWORD dwRet1, dwRet2;
264
265 if (!wom->hAcmStream) {
266 return waveOutUnprepareHeader(wom->hWave, lpWaveHdrSrc, dwParam2);
267 }
268 ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
269 dwRet1 = wom->acmStreamUnprepareHeader(wom->hAcmStream, ash, 0L);
270
271 lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
272 dwRet2 = waveOutUnprepareHeader(wom->hWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
273
274 HeapFree(GetProcessHeap(), 0, ash);
275
276 lpWaveHdrSrc->dwFlags &= ~WHDR_PREPARED;
277 return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
278}
279
280static DWORD wodGetPosition(WAVEMAPDATA* wom, LPMMTIME lpTime, DWORD dwParam2)
281{
282 return waveOutGetPosition(wom->hWave, lpTime, dwParam2);
283}
284
285static DWORD wodGetDevCaps(UINT wDevID, WAVEMAPDATA* wom, LPWAVEOUTCAPSA lpWaveCaps, DWORD dwParam2)
286{
287 /* if opened low driver, forward message */
288 if (WAVEMAP_IsData(wom))
289 return waveOutGetDevCapsA(wom->hWave, lpWaveCaps, dwParam2);
290 /* otherwise, return caps of mapper itself */
291 if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
292 lpWaveCaps->wMid = 0x00FF;
293 lpWaveCaps->wPid = 0x0001;
294 lpWaveCaps->vDriverVersion = 0x0100;
295 strcpy(lpWaveCaps->szPname, "Wine wave out mapper");
296 lpWaveCaps->dwFormats =
297 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
298 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
299 WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
300 lpWaveCaps->wChannels = 2;
301 lpWaveCaps->dwSupport = WAVECAPS_VOLUME | WAVECAPS_LRVOLUME;
302
303 return MMSYSERR_NOERROR;
304 }
305 ERR("This shouldn't happen\n");
306 return MMSYSERR_ERROR;
307}
308
309static DWORD wodGetVolume(UINT wDevID, WAVEMAPDATA* wom, LPDWORD lpVol)
310{
311 if (WAVEMAP_IsData(wom))
312 return waveOutGetVolume(wom->hWave, lpVol);
313 return MMSYSERR_NOERROR;
314}
315
316static DWORD wodSetVolume(UINT wDevID, WAVEMAPDATA* wom, DWORD vol)
317{
318 if (WAVEMAP_IsData(wom))
319 return waveOutSetVolume(wom->hWave, vol);
320 return MMSYSERR_NOERROR;
321}
322
323static DWORD wodPause(WAVEMAPDATA* wom)
324{
325 return waveOutPause(wom->hWave);
326}
327
328static DWORD wodRestart(WAVEMAPDATA* wom)
329{
330 return waveOutRestart(wom->hWave);
331}
332
333static DWORD wodReset(WAVEMAPDATA* wom)
334{
335 return waveOutReset(wom->hWave);
336}
337
338static DWORD wodBreakLoop(WAVEMAPDATA* wom)
339{
340 return waveOutBreakLoop(wom->hWave);
341}
342
343/**************************************************************************
344 * WAVEMAP_wodMessage [sample driver]
345 */
346DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
347 DWORD dwParam1, DWORD dwParam2)
348{
349 TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
350 wDevID, wMsg, dwUser, dwParam1, dwParam2);
351
352 switch (wMsg) {
353 case DRVM_INIT:
354 case DRVM_EXIT:
355 case DRVM_ENABLE:
356 case DRVM_DISABLE:
357 /* FIXME: Pretend this is supported */
358 return 0;
359 case WODM_OPEN: return wodOpen ((LPDWORD)dwUser, (LPWAVEOPENDESC)dwParam1,dwParam2);
360 case WODM_CLOSE: return wodClose ((WAVEMAPDATA*)dwUser);
361 case WODM_WRITE: return wodWrite ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
362 case WODM_PAUSE: return wodPause ((WAVEMAPDATA*)dwUser);
363 case WODM_GETPOS: return wodGetPosition ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1, dwParam2);
364 case WODM_BREAKLOOP: return wodBreakLoop ((WAVEMAPDATA*)dwUser);
365 case WODM_PREPARE: return wodPrepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
366 case WODM_UNPREPARE: return wodUnprepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
367 case WODM_GETDEVCAPS: return wodGetDevCaps (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEOUTCAPSA)dwParam1,dwParam2);
368 case WODM_GETNUMDEVS: return 1;
369 case WODM_GETPITCH: return MMSYSERR_NOTSUPPORTED;
370 case WODM_SETPITCH: return MMSYSERR_NOTSUPPORTED;
371 case WODM_GETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
372 case WODM_SETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
373 case WODM_GETVOLUME: return wodGetVolume (wDevID, (WAVEMAPDATA*)dwUser, (LPDWORD)dwParam1);
374 case WODM_SETVOLUME: return wodSetVolume (wDevID, (WAVEMAPDATA*)dwUser, dwParam1);
375 case WODM_RESTART: return wodRestart ((WAVEMAPDATA*)dwUser);
376 case WODM_RESET: return wodReset ((WAVEMAPDATA*)dwUser);
377 default:
378 FIXME("unknown message %d!\n", wMsg);
379 }
380 return MMSYSERR_NOTSUPPORTED;
381}
382
383/*======================================================================*
384 * WAVE IN part *
385 *======================================================================*/
386
387static DWORD widOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
388{
389 UINT nd = waveInGetNumDevs();
390 UINT i;
391 WAVEMAPDATA* wim = (WAVEMAPDATA*)HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
392
393 TRACE("(%p %p %08lx\n", lpdwUser, lpDesc, dwFlags);
394
395 wim->self = wim;
396
397 for (i = 0; i < nd; i++) {
398 if (waveInOpen(&wim->hWave, i, lpDesc->lpFormat, lpDesc->dwCallback,
399 lpDesc->dwInstance, dwFlags) == MMSYSERR_NOERROR) {
400 lpDesc->hWave = wim->hWave;
401 *lpdwUser = (DWORD)wim;
402 return MMSYSERR_NOERROR;
403 }
404 }
405 HeapFree(GetProcessHeap(), 0, wim);
406 return MMSYSERR_ALLOCATED;
407}
408
409static DWORD widClose(WAVEMAPDATA* wim)
410{
411 DWORD ret = waveInClose(wim->hWave);
412 if (ret == MMSYSERR_NOERROR)
413 HeapFree(GetProcessHeap(), 0, wim);
414 return ret;
415}
416
417static DWORD widAddBuffer(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdr, DWORD dwParam2)
418{
419 return waveInAddBuffer(wim->hWave, lpWaveHdr, dwParam2);
420}
421
422static DWORD widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdr, DWORD dwParam2)
423{
424 return waveInPrepareHeader(wim->hWave, lpWaveHdr, dwParam2);
425}
426
427static DWORD widUnprepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdr, DWORD dwParam2)
428{
429 return waveInUnprepareHeader(wim->hWave, lpWaveHdr, dwParam2);
430}
431
432static DWORD widGetPosition(WAVEMAPDATA* wim, LPMMTIME lpTime, DWORD dwParam2)
433{
434 return waveInGetPosition(wim->hWave, lpTime, dwParam2);
435}
436
437static DWORD widGetDevCaps(UINT wDevID, WAVEMAPDATA* wim, LPWAVEINCAPSA lpWaveCaps, DWORD dwParam2)
438{
439 /* if opened low driver, forward message */
440 if (WAVEMAP_IsData(wim))
441 return waveInGetDevCapsA(wim->hWave, lpWaveCaps, dwParam2);
442 /* otherwise, return caps of mapper itself */
443 if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
444 lpWaveCaps->wMid = 0x00FF;
445 lpWaveCaps->wPid = 0x0001;
446 lpWaveCaps->vDriverVersion = 0x0001;
447 strcpy(lpWaveCaps->szPname, "Wine wave in mapper");
448 lpWaveCaps->dwFormats =
449 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
450 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
451 WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
452 lpWaveCaps->wChannels = 2;
453 return MMSYSERR_NOERROR;
454 }
455 ERR("This shouldn't happen\n");
456 return MMSYSERR_ERROR;
457}
458
459static DWORD widStop(WAVEMAPDATA* wim)
460{
461 return waveInStop(wim->hWave);
462}
463
464static DWORD widStart(WAVEMAPDATA* wim)
465{
466 return waveInStart(wim->hWave);
467}
468
469static DWORD widReset(WAVEMAPDATA* wim)
470{
471 return waveInReset(wim->hWave);
472}
473
474/**************************************************************************
475 * WAVEMAP_widMessage [sample driver]
476 */
477DWORD WINAPI WAVEMAP_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
478 DWORD dwParam1, DWORD dwParam2)
479{
480 TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
481 wDevID, wMsg, dwUser, dwParam1, dwParam2);
482
483 switch (wMsg) {
484 case DRVM_INIT:
485 case DRVM_EXIT:
486 case DRVM_ENABLE:
487 case DRVM_DISABLE:
488 /* FIXME: Pretend this is supported */
489 return 0;
490
491 case WIDM_OPEN: return widOpen ((LPDWORD)dwUser, (LPWAVEOPENDESC)dwParam1, dwParam2);
492 case WIDM_CLOSE: return widClose ((WAVEMAPDATA*)dwUser);
493
494 case WIDM_ADDBUFFER: return widAddBuffer ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
495 case WIDM_PREPARE: return widPrepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
496 case WIDM_UNPREPARE: return widUnprepare ((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
497 case WIDM_GETDEVCAPS: return widGetDevCaps (wDevID, (WAVEMAPDATA*)dwUser, (LPWAVEINCAPSA)dwParam1, dwParam2);
498 case WIDM_GETNUMDEVS: return 1;
499 case WIDM_GETPOS: return widGetPosition ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1, dwParam2);
500 case WIDM_RESET: return widReset ((WAVEMAPDATA*)dwUser);
501 case WIDM_START: return widStart ((WAVEMAPDATA*)dwUser);
502 case WIDM_STOP: return widStop ((WAVEMAPDATA*)dwUser);
503 default:
504 FIXME("unknown message %u!\n", wMsg);
505 }
506 return MMSYSERR_NOTSUPPORTED;
507}
508
509/*======================================================================*
510 * Driver part *
511 *======================================================================*/
512
513static struct WINE_WAVEMAP* oss = NULL;
514
515/**************************************************************************
516 * WAVEMAP_drvOpen [internal]
517 */
518static DWORD WAVEMAP_drvOpen(LPSTR str)
519{
520 if (oss)
521 return 0;
522
523 /* I know, this is ugly, but who cares... */
524 oss = (struct WINE_WAVEMAP*)1;
525 return 1;
526}
527
528/**************************************************************************
529 * WAVEMAP_drvClose [internal]
530 */
531static DWORD WAVEMAP_drvClose(DWORD dwDevID)
532{
533 if (oss) {
534 oss = NULL;
535 return 1;
536 }
537 return 0;
538}
539
540/**************************************************************************
541 * WAVEMAP_DriverProc [internal]
542 */
543LONG CALLBACK WAVEMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
544 DWORD dwParam1, DWORD dwParam2)
545{
546/* EPP TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n", */
547/* EPP dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
548
549 switch(wMsg) {
550 case DRV_LOAD: return 1;
551 case DRV_FREE: return 1;
552 case DRV_OPEN: return WAVEMAP_drvOpen((LPSTR)dwParam1);
553 case DRV_CLOSE: return WAVEMAP_drvClose(dwDevID);
554 case DRV_ENABLE: return 1;
555 case DRV_DISABLE: return 1;
556 case DRV_QUERYCONFIGURE: return 1;
557 case DRV_CONFIGURE: MessageBoxA(0, "WAVEMAP MultiMedia Driver !", "OSS Driver", MB_OK); return 1;
558 case DRV_INSTALL: return DRVCNF_RESTART;
559 case DRV_REMOVE: return DRVCNF_RESTART;
560 default:
561 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
562 }
563}
564
565
Note: See TracBrowser for help on using the repository browser.