?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3drm: Implement IDirect3DRMMesh_GetVertices.
[wine/multimedia.git] / dlls / mmsystem.dll16 / message16.c
blob0935ca0a47c3fbeef3adb7dc2052d7daf05c3fe4
1 /*
2 * MMSYSTEM MCI and low level mapping functions
3 *
4 * Copyright 1999 Eric Pouech
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <string.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <assert.h>
25 #include "wine/winbase16.h"
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "wownt32.h"
30 #include "winemm16.h"
31 #include "digitalv.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
35
36 /* =================================
37 * A U X M A P P E R S
38 * ================================= */
39
40 /* =================================
41 * M I X E R M A P P E R S
42 * ================================= */
43
44 /**************************************************************************
45 * MMSYSTDRV_Mixer_Map16To32W [internal]
46 */
47 static MMSYSTEM_MapType MMSYSTDRV_Mixer_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
48 {
49 return MMSYSTEM_MAP_MSGERROR;
50 }
51
52 /**************************************************************************
53 * MMSYSTDRV_Mixer_UnMap16To32W [internal]
54 */
55 static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
56 {
57 #if 0
58 MIXERCAPSA micA;
59 UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
60
61 if (ret == MMSYSERR_NOERROR) {
62 mixcaps->wMid = micA.wMid;
63 mixcaps->wPid = micA.wPid;
64 mixcaps->vDriverVersion = micA.vDriverVersion;
65 strcpy(mixcaps->szPname, micA.szPname);
66 mixcaps->fdwSupport = micA.fdwSupport;
67 mixcaps->cDestinations = micA.cDestinations;
68 }
69 return ret;
70 #endif
71 return MMSYSTEM_MAP_MSGERROR;
72 }
73
74 /**************************************************************************
75 * MMSYSTDRV_Mixer_MapCB
76 */
77 static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
78 {
79 FIXME("NIY\n");
80 }
81
82 /* =================================
83 * M I D I I N M A P P E R S
84 * ================================= */
85
86 /**************************************************************************
87 * MMSYSTDRV_MidiIn_Map16To32W [internal]
88 */
89 static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
90 {
91 return MMSYSTEM_MAP_MSGERROR;
92 }
93
94 /**************************************************************************
95 * MMSYSTDRV_MidiIn_UnMap16To32W [internal]
96 */
97 static MMSYSTEM_MapType MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
98 {
99 return MMSYSTEM_MAP_MSGERROR;
100 }
101
102 /**************************************************************************
103 * MMSYSTDRV_MidiIn_MapCB [internal]
104 */
105 static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
106 {
107 switch (uMsg) {
108 case MIM_OPEN:
109 case MIM_CLOSE:
110 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
111
112 case MIM_DATA:
113 case MIM_MOREDATA:
114 case MIM_ERROR:
115 /* dwParam1 & dwParam2 are data, nothing to do */
116 break;
117 case MIM_LONGDATA:
118 case MIM_LONGERROR:
119 {
120 LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1);
121 SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
122 LPMIDIHDR mh16 = MapSL(segmh16);
123
124 *dwParam1 = (DWORD)segmh16;
125 mh16->dwFlags = mh32->dwFlags;
126 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
127 if (mh16->reserved >= sizeof(MIDIHDR))
128 mh16->dwOffset = mh32->dwOffset;
129 }
130 break;
131 default:
132 ERR("Unknown msg %u\n", uMsg);
133 }
134 }
135
136 /* =================================
137 * M I D I O U T M A P P E R S
138 * ================================= */
139
140 /**************************************************************************
141 * MMSYSTDRV_MidiOut_Map16To32W [internal]
142 */
143 static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
144 {
145 MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
146
147 switch (wMsg) {
148 case MODM_GETNUMDEVS:
149 case MODM_DATA:
150 case MODM_RESET:
151 case MODM_SETVOLUME:
152 ret = MMSYSTEM_MAP_OK;
153 break;
154
155 case MODM_OPEN:
156 case MODM_CLOSE:
157 case MODM_GETVOLUME:
158 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
159 break;
160
161 case MODM_GETDEVCAPS:
162 {
163 LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW));
164 LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
165
166 if (moc32) {
167 *(LPMIDIOUTCAPS16*)moc32 = moc16;
168 moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
169 *lpParam1 = (DWORD)moc32;
170 *lpParam2 = sizeof(MIDIOUTCAPSW);
171
172 ret = MMSYSTEM_MAP_OKMEM;
173 } else {
174 ret = MMSYSTEM_MAP_NOMEM;
175 }
176 }
177 break;
178 case MODM_PREPARE:
179 {
180 LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
181 LPMIDIHDR mh16 = MapSL(*lpParam1);
182
183 if (mh32) {
184 *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
185 mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
186 mh32->lpData = MapSL((SEGPTR)mh16->lpData);
187 mh32->dwBufferLength = mh16->dwBufferLength;
188 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
189 mh32->dwUser = mh16->dwUser;
190 mh32->dwFlags = mh16->dwFlags;
191 /* FIXME: nothing on mh32->lpNext */
192 /* could link the mh32->lpNext at this level for memory house keeping */
193 mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh16->dwOffset : 0;
194 mh16->lpNext = mh32; /* for reuse in unprepare and write */
195 /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
196 mh16->reserved = *lpParam2;
197 *lpParam1 = (DWORD)mh32;
198 *lpParam2 = sizeof(MIDIHDR);
199
200 ret = MMSYSTEM_MAP_OKMEM;
201 } else {
202 ret = MMSYSTEM_MAP_NOMEM;
203 }
204 }
205 break;
206 case MODM_UNPREPARE:
207 case MODM_LONGDATA:
208 {
209 LPMIDIHDR mh16 = MapSL(*lpParam1);
210 LPMIDIHDR mh32 = mh16->lpNext;
211
212 *lpParam1 = (DWORD)mh32;
213 *lpParam2 = sizeof(MIDIHDR);
214 /* dwBufferLength can be reduced between prepare & write */
215 if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
216 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
217 mh32->dwBufferLength, mh16->dwBufferLength);
218 } else
219 mh32->dwBufferLength = mh16->dwBufferLength;
220 ret = MMSYSTEM_MAP_OKMEM;
221 }
222 break;
223
224 case MODM_CACHEPATCHES:
225 case MODM_CACHEDRUMPATCHES:
226 default:
227 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
228 break;
229 }
230 return ret;
231 }
232
233 /**************************************************************************
234 * MMSYSTDRV_MidiOut_UnMap16To32W [internal]
235 */
236 static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
237 {
238 MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
239
240 switch (wMsg) {
241 case MODM_GETNUMDEVS:
242 case MODM_DATA:
243 case MODM_RESET:
244 case MODM_SETVOLUME:
245 ret = MMSYSTEM_MAP_OK;
246 break;
247
248 case MODM_OPEN:
249 case MODM_CLOSE:
250 case MODM_GETVOLUME:
251 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
252 break;
253
254 case MODM_GETDEVCAPS:
255 {
256 LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1);
257 LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
258
259 moc16->wMid = moc32->wMid;
260 moc16->wPid = moc32->wPid;
261 moc16->vDriverVersion = moc32->vDriverVersion;
262 WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
263 sizeof(moc16->szPname), NULL, NULL );
264 moc16->wTechnology = moc32->wTechnology;
265 moc16->wVoices = moc32->wVoices;
266 moc16->wNotes = moc32->wNotes;
267 moc16->wChannelMask = moc32->wChannelMask;
268 moc16->dwSupport = moc32->dwSupport;
269 HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
270 ret = MMSYSTEM_MAP_OK;
271 }
272 break;
273 case MODM_PREPARE:
274 case MODM_UNPREPARE:
275 case MODM_LONGDATA:
276 {
277 LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
278 LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
279
280 assert(mh16->lpNext == mh32);
281 mh16->dwBufferLength = mh32->dwBufferLength;
282 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
283 mh16->dwUser = mh32->dwUser;
284 mh16->dwFlags = mh32->dwFlags;
285 if (mh16->reserved >= sizeof(MIDIHDR))
286 mh16->dwOffset = mh32->dwOffset;
287
288 if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
289 HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
290 mh16->lpNext = 0;
291 }
292 ret = MMSYSTEM_MAP_OK;
293 }
294 break;
295
296 case MODM_CACHEPATCHES:
297 case MODM_CACHEDRUMPATCHES:
298 default:
299 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
300 break;
301 }
302 return ret;
303 }
304
305 /******************************************************************
306 * MMSYSTDRV_MidiOut_MapCB
307 */
308 static void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
309 {
310 switch (uMsg) {
311 case MOM_OPEN:
312 case MOM_CLOSE:
313 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
314 break;
315 case MOM_DONE:
316 {
317 /* initial map is: 16 => 32 */
318 LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1);
319 SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
320 LPMIDIHDR mh16 = MapSL(segmh16);
321
322 *dwParam1 = (DWORD)segmh16;
323 mh16->dwFlags = mh32->dwFlags;
324 if (mh16->reserved >= sizeof(MIDIHDR))
325 mh16->dwOffset = mh32->dwOffset;
326 }
327 break;
328 case MOM_POSITIONCB:
329 FIXME("NIY\n");
330 /* FIXME: would require to recreate a 16bit MIDIHDR here */
331 *dwParam1 = *dwParam2 = 0;
332 break;
333 default:
334 ERR("Unknown msg %u\n", uMsg);
335 }
336 }
337
338 /* =================================
339 * W A V E I N M A P P E R S
340 * ================================= */
341
342 /**************************************************************************
343 * MMSYSTDRV_WaveIn_Map16To32W [internal]
344 */
345 static MMSYSTEM_MapType MMSYSTDRV_WaveIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
346 {
347 MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
348
349 switch (wMsg) {
350 case WIDM_GETNUMDEVS:
351 case WIDM_RESET:
352 case WIDM_START:
353 case WIDM_STOP:
354 ret = MMSYSTEM_MAP_OK;
355 break;
356 case WIDM_OPEN:
357 case WIDM_CLOSE:
358 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
359 break;
360 case WIDM_GETDEVCAPS:
361 {
362 LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW));
363 LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
364
365 if (wic32) {
366 *(LPWAVEINCAPS16*)wic32 = wic16;
367 wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
368 *lpParam1 = (DWORD)wic32;
369 *lpParam2 = sizeof(WAVEINCAPSW);
370
371 ret = MMSYSTEM_MAP_OKMEM;
372 } else {
373 ret = MMSYSTEM_MAP_NOMEM;
374 }
375 }
376 break;
377 case WIDM_GETPOS:
378 {
379 LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
380 LPMMTIME16 mmt16 = MapSL(*lpParam1);
381
382 if (mmt32) {
383 *(LPMMTIME16*)mmt32 = mmt16;
384 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
385
386 mmt32->wType = mmt16->wType;
387 *lpParam1 = (DWORD)mmt32;
388 *lpParam2 = sizeof(MMTIME);
389
390 ret = MMSYSTEM_MAP_OKMEM;
391 } else {
392 ret = MMSYSTEM_MAP_NOMEM;
393 }
394 }
395 break;
396 case WIDM_PREPARE:
397 {
398 LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
399 LPWAVEHDR wh16 = MapSL(*lpParam1);
400
401 if (wh32) {
402 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
403 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
404 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
405 wh32->dwBufferLength = wh16->dwBufferLength;
406 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
407 wh32->dwUser = wh16->dwUser;
408 wh32->dwFlags = wh16->dwFlags;
409 wh32->dwLoops = wh16->dwLoops;
410 /* FIXME: nothing on wh32->lpNext */
411 /* could link the wh32->lpNext at this level for memory house keeping */
412 wh16->lpNext = wh32; /* for reuse in unprepare and write */
413 *lpParam1 = (DWORD)wh32;
414 *lpParam2 = sizeof(WAVEHDR);
415
416 ret = MMSYSTEM_MAP_OKMEM;
417 } else {
418 ret = MMSYSTEM_MAP_NOMEM;
419 }
420 }
421 break;
422 case WIDM_ADDBUFFER:
423 case WIDM_UNPREPARE:
424 {
425 LPWAVEHDR wh16 = MapSL(*lpParam1);
426 LPWAVEHDR wh32 = wh16->lpNext;
427
428 *lpParam1 = (DWORD)wh32;
429 *lpParam2 = sizeof(WAVEHDR);
430 /* dwBufferLength can be reduced between prepare & write */
431 if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
432 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
433 wh32->dwBufferLength, wh16->dwBufferLength);
434 } else
435 wh32->dwBufferLength = wh16->dwBufferLength;
436 ret = MMSYSTEM_MAP_OKMEM;
437 }
438 break;
439 case WIDM_MAPPER_STATUS:
440 /* just a single DWORD */
441 *lpParam2 = (DWORD)MapSL(*lpParam2);
442 ret = MMSYSTEM_MAP_OK;
443 break;
444 default:
445 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
446 break;
447 }
448 return ret;
449 }
450
451 /**************************************************************************
452 * MMSYSTDRV_WaveIn_UnMap16To32W [internal]
453 */
454 static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
455 {
456 MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
457
458 switch (wMsg) {
459 case WIDM_GETNUMDEVS:
460 case WIDM_RESET:
461 case WIDM_START:
462 case WIDM_STOP:
463 case WIDM_MAPPER_STATUS:
464 ret = MMSYSTEM_MAP_OK;
465 break;
466 case WIDM_OPEN:
467 case WIDM_CLOSE:
468 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
469 break;
470 case WIDM_GETDEVCAPS:
471 {
472 LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1);
473 LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
474
475 wic16->wMid = wic32->wMid;
476 wic16->wPid = wic32->wPid;
477 wic16->vDriverVersion = wic32->vDriverVersion;
478 WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
479 sizeof(wic16->szPname), NULL, NULL );
480 wic16->dwFormats = wic32->dwFormats;
481 wic16->wChannels = wic32->wChannels;
482 HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
483 ret = MMSYSTEM_MAP_OK;
484 }
485 break;
486 case WIDM_GETPOS:
487 {
488 LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
489 LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
490
491 MMSYSTEM_MMTIME32to16(mmt16, mmt32);
492 HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
493 ret = MMSYSTEM_MAP_OK;
494 }
495 break;
496 case WIDM_ADDBUFFER:
497 case WIDM_PREPARE:
498 case WIDM_UNPREPARE:
499 {
500 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
501 LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
502
503 assert(wh16->lpNext == wh32);
504 wh16->dwBufferLength = wh32->dwBufferLength;
505 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
506 wh16->dwUser = wh32->dwUser;
507 wh16->dwFlags = wh32->dwFlags;
508 wh16->dwLoops = wh32->dwLoops;
509
510 if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
511 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
512 wh16->lpNext = 0;
513 }
514 ret = MMSYSTEM_MAP_OK;
515 }
516 break;
517 default:
518 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
519 break;
520 }
521 return ret;
522 }
523
524 /**************************************************************************
525 * MMSYSTDRV_WaveIn_MapCB [internal]
526 */
527 static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
528 {
529 switch (uMsg) {
530 case WIM_OPEN:
531 case WIM_CLOSE:
532 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
533 break;
534 case WIM_DATA:
535 {
536 /* initial map is: 16 => 32 */
537 LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1);
538 SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
539 LPWAVEHDR wh16 = MapSL(segwh16);
540
541 *dwParam1 = (DWORD)segwh16;
542 wh16->dwFlags = wh32->dwFlags;
543 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
544 }
545 break;
546 default:
547 ERR("Unknown msg %u\n", uMsg);
548 }
549 }
550
551 /* =================================
552 * W A V E O U T M A P P E R S
553 * ================================= */
554
555 /**************************************************************************
556 * MMSYSTDRV_WaveOut_Map16To32W [internal]
557 */
558 static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
559 {
560 MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
561
562 switch (wMsg) {
563 /* nothing to do */
564 case WODM_BREAKLOOP:
565 case WODM_CLOSE:
566 case WODM_GETNUMDEVS:
567 case WODM_PAUSE:
568 case WODM_RESET:
569 case WODM_RESTART:
570 case WODM_SETPITCH:
571 case WODM_SETPLAYBACKRATE:
572 case WODM_SETVOLUME:
573 ret = MMSYSTEM_MAP_OK;
574 break;
575
576 case WODM_GETPITCH:
577 case WODM_GETPLAYBACKRATE:
578 case WODM_GETVOLUME:
579 case WODM_OPEN:
580 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
581 break;
582
583 case WODM_GETDEVCAPS:
584 {
585 LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW));
586 LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
587
588 if (woc32) {
589 *(LPWAVEOUTCAPS16*)woc32 = woc16;
590 woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
591 *lpParam1 = (DWORD)woc32;
592 *lpParam2 = sizeof(WAVEOUTCAPSW);
593
594 ret = MMSYSTEM_MAP_OKMEM;
595 } else {
596 ret = MMSYSTEM_MAP_NOMEM;
597 }
598 }
599 break;
600 case WODM_GETPOS:
601 {
602 LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
603 LPMMTIME16 mmt16 = MapSL(*lpParam1);
604
605 if (mmt32) {
606 *(LPMMTIME16*)mmt32 = mmt16;
607 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
608
609 mmt32->wType = mmt16->wType;
610 *lpParam1 = (DWORD)mmt32;
611 *lpParam2 = sizeof(MMTIME);
612
613 ret = MMSYSTEM_MAP_OKMEM;
614 } else {
615 ret = MMSYSTEM_MAP_NOMEM;
616 }
617 }
618 break;
619 case WODM_PREPARE:
620 {
621 LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
622 LPWAVEHDR wh16 = MapSL(*lpParam1);
623
624 if (wh32) {
625 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
626 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
627 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
628 wh32->dwBufferLength = wh16->dwBufferLength;
629 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
630 wh32->dwUser = wh16->dwUser;
631 wh32->dwFlags = wh16->dwFlags;
632 wh32->dwLoops = wh16->dwLoops;
633 /* FIXME: nothing on wh32->lpNext */
634 /* could link the wh32->lpNext at this level for memory house keeping */
635 wh16->lpNext = wh32; /* for reuse in unprepare and write */
636 *lpParam1 = (DWORD)wh32;
637 *lpParam2 = sizeof(WAVEHDR);
638
639 ret = MMSYSTEM_MAP_OKMEM;
640 } else {
641 ret = MMSYSTEM_MAP_NOMEM;
642 }
643 }
644 break;
645 case WODM_UNPREPARE:
646 case WODM_WRITE:
647 {
648 LPWAVEHDR wh16 = MapSL(*lpParam1);
649 LPWAVEHDR wh32 = wh16->lpNext;
650
651 *lpParam1 = (DWORD)wh32;
652 *lpParam2 = sizeof(WAVEHDR);
653 /* dwBufferLength can be reduced between prepare & write */
654 if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
655 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
656 wh32->dwBufferLength, wh16->dwBufferLength);
657 } else
658 wh32->dwBufferLength = wh16->dwBufferLength;
659 ret = MMSYSTEM_MAP_OKMEM;
660 }
661 break;
662 case WODM_MAPPER_STATUS:
663 *lpParam2 = (DWORD)MapSL(*lpParam2);
664 ret = MMSYSTEM_MAP_OK;
665 break;
666 default:
667 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
668 break;
669 }
670 return ret;
671 }
672
673 /**************************************************************************
674 * MMSYSTDRV_WaveOut_UnMap16To32W [internal]
675 */
676 static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
677 {
678 MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
679
680 switch (wMsg) {
681 /* nothing to do */
682 case WODM_BREAKLOOP:
683 case WODM_CLOSE:
684 case WODM_GETNUMDEVS:
685 case WODM_PAUSE:
686 case WODM_RESET:
687 case WODM_RESTART:
688 case WODM_SETPITCH:
689 case WODM_SETPLAYBACKRATE:
690 case WODM_SETVOLUME:
691 case WODM_MAPPER_STATUS:
692 ret = MMSYSTEM_MAP_OK;
693 break;
694
695 case WODM_GETPITCH:
696 case WODM_GETPLAYBACKRATE:
697 case WODM_GETVOLUME:
698 case WODM_OPEN:
699 FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
700 break;
701
702 case WODM_GETDEVCAPS:
703 {
704 LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1);
705 LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
706
707 woc16->wMid = woc32->wMid;
708 woc16->wPid = woc32->wPid;
709 woc16->vDriverVersion = woc32->vDriverVersion;
710 WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
711 sizeof(woc16->szPname), NULL, NULL );
712 woc16->dwFormats = woc32->dwFormats;
713 woc16->wChannels = woc32->wChannels;
714 woc16->dwSupport = woc32->dwSupport;
715 HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
716 ret = MMSYSTEM_MAP_OK;
717 }
718 break;
719 case WODM_GETPOS:
720 {
721 LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
722 LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
723
724 MMSYSTEM_MMTIME32to16(mmt16, mmt32);
725 HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
726 ret = MMSYSTEM_MAP_OK;
727 }
728 break;
729 case WODM_PREPARE:
730 case WODM_UNPREPARE:
731 case WODM_WRITE:
732 {
733 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
734 LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
735
736 assert(wh16->lpNext == wh32);
737 wh16->dwBufferLength = wh32->dwBufferLength;
738 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
739 wh16->dwUser = wh32->dwUser;
740 wh16->dwFlags = wh32->dwFlags;
741 wh16->dwLoops = wh32->dwLoops;
742
743 if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
744 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
745 wh16->lpNext = 0;
746 }
747 ret = MMSYSTEM_MAP_OK;
748 }
749 break;
750 default:
751 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
752 break;
753 }
754 return ret;
755 }
756
757 /**************************************************************************
758 * MMDRV_WaveOut_Callback [internal]
759 */
760 static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
761 {
762 switch (uMsg) {
763 case WOM_OPEN:
764 case WOM_CLOSE:
765 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
766 break;
767 case WOM_DONE:
768 {
769 /* initial map is: 16 => 32 */
770 LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1);
771 SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
772 LPWAVEHDR wh16 = MapSL(segwh16);
773
774 *dwParam1 = (DWORD)segwh16;
775 wh16->dwFlags = wh32->dwFlags;
776 }
777 break;
778 default:
779 ERR("Unknown msg %u\n", uMsg);
780 }
781 }
782
783 /* ###################################################
784 * # DRIVER THUNKING #
785 * ###################################################
786 */
787 typedef MMSYSTEM_MapType (*MMSYSTDRV_MAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2);
788 typedef MMSYSTEM_MapType (*MMSYSTDRV_UNMAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret);
789 typedef void (*MMSYSTDRV_MAPCB)(DWORD wMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2);
790
791 #include <pshpack1.h>
792 #define MMSYSTDRV_MAX_THUNKS 32
793
794 static struct mmsystdrv_thunk
795 {
796 BYTE popl_eax; /* popl %eax (return address) */
797 BYTE pushl_this; /* pushl this (this very thunk) */
798 struct mmsystdrv_thunk* this;
799 BYTE pushl_eax; /* pushl %eax */
800 BYTE jmp; /* ljmp MMDRV_Callback3216 */
801 DWORD callback3216;
802 DWORD callback; /* callback value (function, window, event...) */
803 DWORD flags; /* flags to control callback value (CALLBACK_???) */
804 void* hMmdrv; /* Handle to 32bit mmdrv object */
805 enum MMSYSTEM_DriverType kind;
806 } *MMSYSTDRV_Thunks;
807
808 #include <poppack.h>
809
810 static struct MMSYSTDRV_Type
811 {
812 MMSYSTDRV_MAPMSG mapmsg16to32W;
813 MMSYSTDRV_UNMAPMSG unmapmsg16to32W;
814 MMSYSTDRV_MAPCB mapcb;
815 } MMSYSTEM_DriversType[MMSYSTDRV_MAX] =
816 {
817 {MMSYSTDRV_Mixer_Map16To32W, MMSYSTDRV_Mixer_UnMap16To32W, MMSYSTDRV_Mixer_MapCB},
818 {MMSYSTDRV_MidiIn_Map16To32W, MMSYSTDRV_MidiIn_UnMap16To32W, MMSYSTDRV_MidiIn_MapCB},
819 {MMSYSTDRV_MidiOut_Map16To32W, MMSYSTDRV_MidiOut_UnMap16To32W, MMSYSTDRV_MidiOut_MapCB},
820 {MMSYSTDRV_WaveIn_Map16To32W, MMSYSTDRV_WaveIn_UnMap16To32W, MMSYSTDRV_WaveIn_MapCB},
821 {MMSYSTDRV_WaveOut_Map16To32W, MMSYSTDRV_WaveOut_UnMap16To32W, MMSYSTDRV_WaveOut_MapCB},
822 };
823
824 /******************************************************************
825 * MMSYSTDRV_Callback3216
826 *
827 */
828 static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, HDRVR hDev,
829 DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
830 DWORD_PTR dwParam2)
831 {
832 WORD args[8];
833
834 assert(thunk->kind < MMSYSTDRV_MAX);
835 assert(MMSYSTEM_DriversType[thunk->kind].mapcb);
836
837 MMSYSTEM_DriversType[thunk->kind].mapcb(wMsg, &dwUser, &dwParam1, &dwParam2);
838
839 switch (thunk->flags & CALLBACK_TYPEMASK) {
840 case CALLBACK_NULL:
841 TRACE("Null !\n");
842 break;
843 case CALLBACK_WINDOW:
844 TRACE("Window(%04X) handle=%p!\n", thunk->callback, hDev);
845 PostMessageA((HWND)thunk->callback, wMsg, (WPARAM)hDev, dwParam1);
846 break;
847 case CALLBACK_TASK: /* aka CALLBACK_THREAD */
848 TRACE("Task(%04x) !\n", thunk->callback);
849 PostThreadMessageA(thunk->callback, wMsg, (WPARAM)hDev, dwParam1);
850 break;
851 case CALLBACK_FUNCTION:
852 /* 16 bit func, call it */
853 TRACE("Function (16 bit) %x!\n", thunk->callback);
854
855 args[7] = HDRVR_16(hDev);
856 args[6] = wMsg;
857 args[5] = HIWORD(dwUser);
858 args[4] = LOWORD(dwUser);
859 args[3] = HIWORD(dwParam1);
860 args[2] = LOWORD(dwParam1);
861 args[1] = HIWORD(dwParam2);
862 args[0] = LOWORD(dwParam2);
863 return WOWCallback16Ex(thunk->callback, WCB16_PASCAL, sizeof(args), args, NULL);
864 case CALLBACK_EVENT:
865 TRACE("Event(%08x) !\n", thunk->callback);
866 SetEvent((HANDLE)thunk->callback);
867 break;
868 default:
869 WARN("Unknown callback type %x\n", thunk->flags & CALLBACK_TYPEMASK);
870 return FALSE;
871 }
872 TRACE("Done\n");
873 return TRUE;
874 }
875
876 /******************************************************************
877 * MMSYSTDRV_AddThunk
878 *
879 */
880 struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, enum MMSYSTEM_DriverType kind)
881 {
882 struct mmsystdrv_thunk* thunk;
883
884 EnterCriticalSection(&mmdrv_cs);
885 if (!MMSYSTDRV_Thunks)
886 {
887 MMSYSTDRV_Thunks = VirtualAlloc(NULL, MMSYSTDRV_MAX_THUNKS * sizeof(*MMSYSTDRV_Thunks),
888 MEM_COMMIT, PAGE_EXECUTE_READWRITE);
889 if (!MMSYSTDRV_Thunks)
890 {
891 LeaveCriticalSection(&mmdrv_cs);
892 return NULL;
893 }
894 for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
895 {
896 thunk->popl_eax = 0x58; /* popl %eax */
897 thunk->pushl_this = 0x68; /* pushl this */
898 thunk->this = thunk;
899 thunk->pushl_eax = 0x50; /* pushl %eax */
900 thunk->jmp = 0xe9; /* jmp MMDRV_Callback3216 */
901 thunk->callback3216 = (char *)MMSYSTDRV_Callback3216 - (char *)(&thunk->callback3216 + 1);
902 thunk->callback = 0;
903 thunk->flags = CALLBACK_NULL;
904 thunk->hMmdrv = NULL;
905 thunk->kind = MMSYSTDRV_MAX;
906 }
907 }
908 for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
909 {
910 if (thunk->callback == 0 && thunk->hMmdrv == NULL)
911 {
912 thunk->callback = callback;
913 thunk->flags = flags;
914 thunk->hMmdrv = NULL;
915 thunk->kind = kind;
916 LeaveCriticalSection(&mmdrv_cs);
917 return thunk;
918 }
919 }
920 LeaveCriticalSection(&mmdrv_cs);
921 FIXME("Out of mmdrv-thunks. Bump MMDRV_MAX_THUNKS\n");
922 return NULL;
923 }
924
925 /******************************************************************
926 * MMSYSTDRV_FindHandle
927 *
928 * Must be called with lock set
929 */
930 static void* MMSYSTDRV_FindHandle(void* h)
931 {
932 struct mmsystdrv_thunk* thunk;
933
934 for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
935 {
936 if (thunk->hMmdrv == h)
937 {
938 if (thunk->kind >= MMSYSTDRV_MAX) FIXME("Kind isn't properly initialized %x\n", thunk->kind);
939 return thunk;
940 }
941 }
942 return NULL;
943 }
944
945 /******************************************************************
946 * MMSYSTDRV_SetHandle
947 *
948 */
949 void MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h)
950 {
951 if (MMSYSTDRV_FindHandle(h)) FIXME("Already has a thunk for this handle %p!!!\n", h);
952 thunk->hMmdrv = h;
953 }
954
955 /******************************************************************
956 * MMSYSTDRV_DeleteThunk
957 */
958 void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk)
959 {
960 thunk->callback = 0;
961 thunk->flags = CALLBACK_NULL;
962 thunk->hMmdrv = NULL;
963 thunk->kind = MMSYSTDRV_MAX;
964 }
965
966 /******************************************************************
967 * MMSYSTDRV_CloseHandle
968 */
969 void MMSYSTDRV_CloseHandle(void* h)
970 {
971 struct mmsystdrv_thunk* thunk;
972
973 EnterCriticalSection(&mmdrv_cs);
974 if ((thunk = MMSYSTDRV_FindHandle(h)))
975 {
976 MMSYSTDRV_DeleteThunk(thunk);
977 }
978 LeaveCriticalSection(&mmdrv_cs);
979 }
980
981 /******************************************************************
982 * MMSYSTDRV_Message
983 */
984 DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2)
985 {
986 struct mmsystdrv_thunk* thunk = MMSYSTDRV_FindHandle(h);
987 struct MMSYSTDRV_Type* drvtype;
988 MMSYSTEM_MapType map;
989 DWORD ret;
990
991 if (!thunk) return MMSYSERR_INVALHANDLE;
992 drvtype = &MMSYSTEM_DriversType[thunk->kind];
993
994 map = drvtype->mapmsg16to32W(msg, &param1, &param2);
995 switch (map) {
996 case MMSYSTEM_MAP_NOMEM:
997 ret = MMSYSERR_NOMEM;
998 break;
999 case MMSYSTEM_MAP_MSGERROR:
1000 FIXME("NIY: no conversion yet 16->32 kind=%u msg=%u\n", thunk->kind, msg);
1001 ret = MMSYSERR_ERROR;
1002 break;
1003 case MMSYSTEM_MAP_OK:
1004 case MMSYSTEM_MAP_OKMEM:
1005 TRACE("Calling message(msg=%u p1=0x%08lx p2=0x%08lx)\n",
1006 msg, param1, param2);
1007 switch (thunk->kind)
1008 {
1009 case MMSYSTDRV_MIXER: ret = mixerMessage (h, msg, param1, param2); break;
1010 case MMSYSTDRV_MIDIIN:
1011 switch (msg)
1012 {
1013 case MIDM_ADDBUFFER: ret = midiInAddBuffer(h, (LPMIDIHDR)param1, param2); break;
1014 case MIDM_PREPARE: ret = midiInPrepareHeader(h, (LPMIDIHDR)param1, param2); break;
1015 case MIDM_UNPREPARE: ret = midiInUnprepareHeader(h, (LPMIDIHDR)param1, param2); break;
1016 default: ret = midiInMessage(h, msg, param1, param2); break;
1017 }
1018 break;
1019 case MMSYSTDRV_MIDIOUT:
1020 switch (msg)
1021 {
1022 case MODM_PREPARE: ret = midiOutPrepareHeader(h, (LPMIDIHDR)param1, param2); break;
1023 case MODM_UNPREPARE: ret = midiOutUnprepareHeader(h, (LPMIDIHDR)param1, param2); break;
1024 case MODM_LONGDATA: ret = midiOutLongMsg(h, (LPMIDIHDR)param1, param2); break;
1025 default: ret = midiOutMessage(h, msg, param1, param2); break;
1026 }
1027 break;
1028 case MMSYSTDRV_WAVEIN:
1029 switch (msg)
1030 {
1031 case WIDM_ADDBUFFER: ret = waveInAddBuffer(h, (LPWAVEHDR)param1, param2); break;
1032 case WIDM_PREPARE: ret = waveInPrepareHeader(h, (LPWAVEHDR)param1, param2); break;
1033 case WIDM_UNPREPARE: ret = waveInUnprepareHeader(h, (LPWAVEHDR)param1, param2); break;
1034 default: ret = waveInMessage(h, msg, param1, param2); break;
1035 }
1036 break;
1037 case MMSYSTDRV_WAVEOUT:
1038 switch (msg)
1039 {
1040 case WODM_PREPARE: ret = waveOutPrepareHeader(h, (LPWAVEHDR)param1, param2); break;
1041 case WODM_UNPREPARE: ret = waveOutUnprepareHeader(h, (LPWAVEHDR)param1, param2); break;
1042 case WODM_WRITE: ret = waveOutWrite(h, (LPWAVEHDR)param1, param2); break;
1043 default: ret = waveOutMessage(h, msg, param1, param2); break;
1044 }
1045 break;
1046 default: ret = MMSYSERR_INVALHANDLE; break; /* should never be reached */
1047 }
1048 if (map == MMSYSTEM_MAP_OKMEM)
1049 drvtype->unmapmsg16to32W(msg, &param1, &param2, ret);
1050 break;
1051 default:
1052 FIXME("NIY\n");
1053 ret = MMSYSERR_NOTSUPPORTED;
1054 break;
1055 }
1056 return ret;
1057 }
Maarten's multimedia branch