?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rpcrt4/tests: Replace || by |.
[wine/multimedia.git] / dlls / winmm / message16.c
blob14dbbf416806c63c1bf928b95f0e76edb7b20c7d
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 "winreg.h"
29 #include "winver.h"
30 #include "wownt32.h"
31 #include "winemm16.h"
32 #include "digitalv.h"
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
36
37 /**************************************************************************
38 * MMDRV_Callback [internal]
39 */
40 static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
41 {
42 TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n",
43 mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2);
44
45 if (!mld->bFrom32 && (mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION)
46 {
47 WORD args[8];
48 /* 16 bit func, call it */
49 TRACE("Function (16 bit) !\n");
50
51 args[7] = HDRVR_16(hDev);
52 args[6] = uMsg;
53 args[5] = HIWORD(mld->dwClientInstance);
54 args[4] = LOWORD(mld->dwClientInstance);
55 args[3] = HIWORD(dwParam1);
56 args[2] = LOWORD(dwParam1);
57 args[1] = HIWORD(dwParam2);
58 args[0] = LOWORD(dwParam2);
59 WOWCallback16Ex( mld->dwCallback, WCB16_PASCAL, sizeof(args), args, NULL );
60 } else {
61 DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg,
62 mld->dwClientInstance, dwParam1, dwParam2);
63 }
64 }
65
66 /* =================================
67 * A U X M A P P E R S
68 * ================================= */
69
70 /**************************************************************************
71 * MMDRV_Aux_Map16To32W [internal]
72 */
73 static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
74 {
75 return WINMM_MAP_MSGERROR;
76 }
77
78 /**************************************************************************
79 * MMDRV_Aux_UnMap16To32W [internal]
80 */
81 static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
82 {
83 return WINMM_MAP_MSGERROR;
84 }
85
86 /**************************************************************************
87 * MMDRV_Aux_Map32WTo16 [internal]
88 */
89 static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
90 {
91 return WINMM_MAP_MSGERROR;
92 }
93
94 /**************************************************************************
95 * MMDRV_Aux_UnMap32WTo16 [internal]
96 */
97 static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
98 {
99 #if 0
100 case AUXDM_GETDEVCAPS:
101 lpCaps->wMid = ac16.wMid;
102 lpCaps->wPid = ac16.wPid;
103 lpCaps->vDriverVersion = ac16.vDriverVersion;
104 strcpy(lpCaps->szPname, ac16.szPname);
105 lpCaps->wTechnology = ac16.wTechnology;
106 lpCaps->dwSupport = ac16.dwSupport;
107 #endif
108 return WINMM_MAP_MSGERROR;
109 }
110
111 /**************************************************************************
112 * MMDRV_Aux_Callback [internal]
113 */
114 static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
115 {
116 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
117
118 FIXME("NIY\n");
119 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
120 }
121
122 /* =================================
123 * M I X E R M A P P E R S
124 * ================================= */
125
126 /**************************************************************************
127 * xMMDRV_Mixer_Map16To32W [internal]
128 */
129 static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
130 {
131 return WINMM_MAP_MSGERROR;
132 }
133
134 /**************************************************************************
135 * MMDRV_Mixer_UnMap16To32W [internal]
136 */
137 static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
138 {
139 #if 0
140 MIXERCAPSA micA;
141 UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
142
143 if (ret == MMSYSERR_NOERROR) {
144 mixcaps->wMid = micA.wMid;
145 mixcaps->wPid = micA.wPid;
146 mixcaps->vDriverVersion = micA.vDriverVersion;
147 strcpy(mixcaps->szPname, micA.szPname);
148 mixcaps->fdwSupport = micA.fdwSupport;
149 mixcaps->cDestinations = micA.cDestinations;
150 }
151 return ret;
152 #endif
153 return WINMM_MAP_MSGERROR;
154 }
155
156 /**************************************************************************
157 * MMDRV_Mixer_Map32WTo16 [internal]
158 */
159 static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
160 {
161 return WINMM_MAP_MSGERROR;
162 }
163
164 /**************************************************************************
165 * MMDRV_Mixer_UnMap32WTo16 [internal]
166 */
167 static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
168 {
169 return WINMM_MAP_MSGERROR;
170 }
171
172 /**************************************************************************
173 * MMDRV_Mixer_Callback [internal]
174 */
175 static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
176 {
177 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
178
179 FIXME("NIY\n");
180 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
181 }
182
183 /* =================================
184 * M I D I I N M A P P E R S
185 * ================================= */
186
187 /**************************************************************************
188 * MMDRV_MidiIn_Map16To32W [internal]
189 */
190 static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
191 {
192 return WINMM_MAP_MSGERROR;
193 }
194
195 /**************************************************************************
196 * MMDRV_MidiIn_UnMap16To32W [internal]
197 */
198 static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
199 {
200 return WINMM_MAP_MSGERROR;
201 }
202
203 /**************************************************************************
204 * MMDRV_MidiIn_Map32WTo16 [internal]
205 */
206 static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
207 {
208 return WINMM_MAP_MSGERROR;
209 }
210
211 /**************************************************************************
212 * MMDRV_MidiIn_UnMap32WTo16 [internal]
213 */
214 static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
215 {
216 return WINMM_MAP_MSGERROR;
217 }
218
219 /**************************************************************************
220 * MMDRV_MidiIn_Callback [internal]
221 */
222 static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
223 {
224 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
225
226 switch (uMsg) {
227 case MIM_OPEN:
228 case MIM_CLOSE:
229 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
230
231 case MIM_DATA:
232 case MIM_MOREDATA:
233 case MIM_ERROR:
234 /* dwParam1 & dwParam2 are data, nothing to do */
235 break;
236 case MIM_LONGDATA:
237 case MIM_LONGERROR:
238 /* dwParam1 points to a MidiHdr, work to be done !!! */
239 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
240 /* initial map is: 32 => 16 */
241 LPMIDIHDR mh16 = MapSL(dwParam1);
242 LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
243
244 dwParam1 = (DWORD)mh32;
245 mh32->dwFlags = mh16->dwFlags;
246 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
247 if (mh32->reserved >= sizeof(MIDIHDR))
248 mh32->dwOffset = mh16->dwOffset;
249 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
250 /* initial map is: 16 => 32 */
251 LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1);
252 SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
253 LPMIDIHDR mh16 = MapSL(segmh16);
254
255 dwParam1 = (DWORD)segmh16;
256 mh16->dwFlags = mh32->dwFlags;
257 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
258 if (mh16->reserved >= sizeof(MIDIHDR))
259 mh16->dwOffset = mh32->dwOffset;
260 }
261 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
262 break;
263 /* case MOM_POSITIONCB: */
264 default:
265 ERR("Unknown msg %u\n", uMsg);
266 }
267
268 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
269 }
270
271 /* =================================
272 * M I D I O U T M A P P E R S
273 * ================================= */
274
275 /**************************************************************************
276 * MMDRV_MidiOut_Map16To32W [internal]
277 */
278 static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
279 {
280 WINMM_MapType ret = WINMM_MAP_MSGERROR;
281
282 switch (wMsg) {
283 case MODM_GETNUMDEVS:
284 case MODM_DATA:
285 case MODM_RESET:
286 case MODM_SETVOLUME:
287 ret = WINMM_MAP_OK;
288 break;
289
290 case MODM_OPEN:
291 case MODM_CLOSE:
292 case MODM_GETVOLUME:
293 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
294 break;
295
296 case MODM_GETDEVCAPS:
297 {
298 LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW));
299 LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
300
301 if (moc32) {
302 *(LPMIDIOUTCAPS16*)moc32 = moc16;
303 moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
304 *lpParam1 = (DWORD)moc32;
305 *lpParam2 = sizeof(MIDIOUTCAPSW);
306
307 ret = WINMM_MAP_OKMEM;
308 } else {
309 ret = WINMM_MAP_NOMEM;
310 }
311 }
312 break;
313 case MODM_PREPARE:
314 {
315 LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
316 LPMIDIHDR mh16 = MapSL(*lpParam1);
317
318 if (mh32) {
319 *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
320 mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
321 mh32->lpData = MapSL((SEGPTR)mh16->lpData);
322 mh32->dwBufferLength = mh16->dwBufferLength;
323 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
324 mh32->dwUser = mh16->dwUser;
325 mh32->dwFlags = mh16->dwFlags;
326 /* FIXME: nothing on mh32->lpNext */
327 /* could link the mh32->lpNext at this level for memory house keeping */
328 mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0;
329 mh16->lpNext = mh32; /* for reuse in unprepare and write */
330 /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
331 mh16->reserved = *lpParam2;
332 *lpParam1 = (DWORD)mh32;
333 *lpParam2 = sizeof(MIDIHDR);
334
335 ret = WINMM_MAP_OKMEM;
336 } else {
337 ret = WINMM_MAP_NOMEM;
338 }
339 }
340 break;
341 case MODM_UNPREPARE:
342 case MODM_LONGDATA:
343 {
344 LPMIDIHDR mh16 = MapSL(*lpParam1);
345 LPMIDIHDR mh32 = (LPMIDIHDR)mh16->lpNext;
346
347 *lpParam1 = (DWORD)mh32;
348 *lpParam2 = sizeof(MIDIHDR);
349 /* dwBufferLength can be reduced between prepare & write */
350 if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
351 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
352 mh32->dwBufferLength, mh16->dwBufferLength);
353 } else
354 mh32->dwBufferLength = mh16->dwBufferLength;
355 ret = WINMM_MAP_OKMEM;
356 }
357 break;
358
359 case MODM_CACHEPATCHES:
360 case MODM_CACHEDRUMPATCHES:
361 default:
362 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
363 break;
364 }
365 return ret;
366 }
367
368 /**************************************************************************
369 * MMDRV_MidiOut_UnMap16To32W [internal]
370 */
371 static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
372 {
373 WINMM_MapType ret = WINMM_MAP_MSGERROR;
374
375 switch (wMsg) {
376 case MODM_GETNUMDEVS:
377 case MODM_DATA:
378 case MODM_RESET:
379 case MODM_SETVOLUME:
380 ret = WINMM_MAP_OK;
381 break;
382
383 case MODM_OPEN:
384 case MODM_CLOSE:
385 case MODM_GETVOLUME:
386 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
387 break;
388
389 case MODM_GETDEVCAPS:
390 {
391 LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1);
392 LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
393
394 moc16->wMid = moc32->wMid;
395 moc16->wPid = moc32->wPid;
396 moc16->vDriverVersion = moc32->vDriverVersion;
397 WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
398 sizeof(moc16->szPname), NULL, NULL );
399 moc16->wTechnology = moc32->wTechnology;
400 moc16->wVoices = moc32->wVoices;
401 moc16->wNotes = moc32->wNotes;
402 moc16->wChannelMask = moc32->wChannelMask;
403 moc16->dwSupport = moc32->dwSupport;
404 HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
405 ret = WINMM_MAP_OK;
406 }
407 break;
408 case MODM_PREPARE:
409 case MODM_UNPREPARE:
410 case MODM_LONGDATA:
411 {
412 LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
413 LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
414
415 assert(mh16->lpNext == mh32);
416 mh16->dwBufferLength = mh32->dwBufferLength;
417 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
418 mh16->dwUser = mh32->dwUser;
419 mh16->dwFlags = mh32->dwFlags;
420 if (mh16->reserved >= sizeof(MIDIHDR))
421 mh16->dwOffset = mh32->dwOffset;
422
423 if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
424 HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
425 mh16->lpNext = 0;
426 }
427 ret = WINMM_MAP_OK;
428 }
429 break;
430
431 case MODM_CACHEPATCHES:
432 case MODM_CACHEDRUMPATCHES:
433 default:
434 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
435 break;
436 }
437 return ret;
438 }
439
440 /**************************************************************************
441 * MMDRV_MidiOut_Map32WTo16 [internal]
442 */
443 static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
444 {
445 WINMM_MapType ret = WINMM_MAP_MSGERROR;
446
447 switch (wMsg) {
448 case MODM_CLOSE:
449 case MODM_GETNUMDEVS:
450 case MODM_DATA:
451 case MODM_RESET:
452 case MODM_SETVOLUME:
453 ret = WINMM_MAP_OK;
454 break;
455 case MODM_GETDEVCAPS:
456 {
457 LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)*lpParam1;
458 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSW)+sizeof(MIDIOUTCAPS16));
459
460 if (ptr) {
461 *(LPMIDIOUTCAPSW*)ptr = moc32;
462 ret = WINMM_MAP_OKMEM;
463 } else {
464 ret = WINMM_MAP_NOMEM;
465 }
466 *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSW);
467 *lpParam2 = sizeof(MIDIOUTCAPS16);
468 }
469 break;
470 case MODM_PREPARE:
471 {
472 LPMIDIHDR mh32 = (LPMIDIHDR)*lpParam1;
473 LPMIDIHDR mh16;
474 LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
475 sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength);
476
477 if (ptr) {
478 *(LPMIDIHDR*)ptr = mh32;
479 mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR));
480 *lpParam1 = MapLS(mh16);
481 mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR);
482 /* data will be copied on WODM_WRITE */
483 mh16->dwBufferLength = mh32->dwBufferLength;
484 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
485 mh16->dwUser = mh32->dwUser;
486 mh16->dwFlags = mh32->dwFlags;
487 /* FIXME: nothing on mh32->lpNext */
488 /* could link the mh32->lpNext at this level for memory house keeping */
489 mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0;
490
491 mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */
492 mh32->reserved = *lpParam2;
493
494 TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
495 *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
496 *lpParam2 = sizeof(MIDIHDR);
497
498 ret = WINMM_MAP_OKMEM;
499 } else {
500 ret = WINMM_MAP_NOMEM;
501 }
502 }
503 break;
504 case MODM_UNPREPARE:
505 case MODM_LONGDATA:
506 {
507 LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
508 LPMIDIHDR mh16 = (LPMIDIHDR)mh32->lpNext;
509 LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
510
511 assert(*(LPMIDIHDR*)ptr == mh32);
512
513 if (wMsg == MODM_LONGDATA)
514 memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength);
515
516 *lpParam1 = MapLS(mh16);
517 *lpParam2 = sizeof(MIDIHDR);
518 TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
519 *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
520
521 /* dwBufferLength can be reduced between prepare & write */
522 if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
523 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
524 mh16->dwBufferLength, mh32->dwBufferLength);
525 } else
526 mh16->dwBufferLength = mh32->dwBufferLength;
527 ret = WINMM_MAP_OKMEM;
528 }
529 break;
530 case MODM_OPEN:
531 {
532 LPMIDIOPENDESC mod32 = (LPMIDIOPENDESC)*lpParam1;
533 LPVOID ptr;
534 LPMIDIOPENDESC16 mod16;
535
536 /* allocated data are mapped as follows:
537 LPMIDIOPENDESC ptr to orig lParam1
538 DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
539 DWORD dwUser passed to driver
540 MIDIOPENDESC16 mod16: openDesc passed to driver
541 MIDIOPENSTRMID cIds
542 */
543 ptr = HeapAlloc( GetProcessHeap(), 0,
544 sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) +
545 mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0);
546
547 if (ptr) {
548 SEGPTR segptr = MapLS(ptr);
549 *(LPMIDIOPENDESC*)ptr = mod32;
550 *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser;
551 mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD));
552
553 mod16->hMidi = HMIDI_16(mod32->hMidi);
554 mod16->dwCallback = mod32->dwCallback;
555 mod16->dwInstance = mod32->dwInstance;
556 mod16->dnDevNode = mod32->dnDevNode;
557 mod16->cIds = mod32->cIds;
558 memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID));
559
560 *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
561 *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
562
563 ret = WINMM_MAP_OKMEM;
564 } else {
565 ret = WINMM_MAP_NOMEM;
566 }
567 }
568 break;
569 case MODM_GETVOLUME:
570 case MODM_CACHEPATCHES:
571 case MODM_CACHEDRUMPATCHES:
572 default:
573 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
574 break;
575 }
576 return ret;
577 }
578
579 /**************************************************************************
580 * MMDRV_MidiOut_UnMap32WTo16 [internal]
581 */
582 static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
583 {
584 WINMM_MapType ret = WINMM_MAP_MSGERROR;
585
586 switch (wMsg) {
587 case MODM_CLOSE:
588 case MODM_GETNUMDEVS:
589 case MODM_DATA:
590 case MODM_RESET:
591 case MODM_SETVOLUME:
592 ret = WINMM_MAP_OK;
593 break;
594 case MODM_GETDEVCAPS:
595 {
596 LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
597 LPSTR ptr = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSW);
598 LPMIDIOUTCAPSW moc32 = *(LPMIDIOUTCAPSW*)ptr;
599
600 moc32->wMid = moc16->wMid;
601 moc32->wPid = moc16->wPid;
602 moc32->vDriverVersion = moc16->vDriverVersion;
603 WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
604 sizeof(moc16->szPname), NULL, NULL );
605 moc32->wTechnology = moc16->wTechnology;
606 moc32->wVoices = moc16->wVoices;
607 moc32->wNotes = moc16->wNotes;
608 moc32->wChannelMask = moc16->wChannelMask;
609 moc32->dwSupport = moc16->dwSupport;
610 UnMapLS( *lpParam1 );
611 HeapFree( GetProcessHeap(), 0, ptr );
612 ret = WINMM_MAP_OK;
613 }
614 break;
615 case MODM_PREPARE:
616 case MODM_UNPREPARE:
617 case MODM_LONGDATA:
618 {
619 LPMIDIHDR mh16 = MapSL(*lpParam1);
620 LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
621 LPMIDIHDR mh32 = *(LPMIDIHDR*)ptr;
622
623 assert(mh32->lpNext == (LPMIDIHDR)mh16);
624 UnMapLS( *lpParam1 );
625 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
626 mh32->dwUser = mh16->dwUser;
627 mh32->dwFlags = mh16->dwFlags;
628
629 if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
630 HeapFree( GetProcessHeap(), 0, ptr );
631 mh32->lpNext = 0;
632 }
633 ret = WINMM_MAP_OK;
634 }
635 break;
636 case MODM_OPEN:
637 {
638 LPMIDIOPENDESC16 mod16 = MapSL(*lpParam1);
639 LPSTR ptr = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD);
640 UnMapLS( *lpParam1 );
641 **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
642
643 HeapFree( GetProcessHeap(), 0, ptr );
644 ret = WINMM_MAP_OK;
645 }
646 break;
647 case MODM_GETVOLUME:
648 case MODM_CACHEPATCHES:
649 case MODM_CACHEDRUMPATCHES:
650 default:
651 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
652 break;
653 }
654 return ret;
655 }
656
657 /**************************************************************************
658 * MMDRV_MidiOut_Callback [internal]
659 */
660 static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
661 {
662 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
663
664 switch (uMsg) {
665 case MOM_OPEN:
666 case MOM_CLOSE:
667 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
668 break;
669 case MOM_DONE:
670 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
671 /* initial map is: 32 => 16 */
672 LPMIDIHDR mh16 = MapSL(dwParam1);
673 LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
674
675 dwParam1 = (DWORD)mh32;
676 mh32->dwFlags = mh16->dwFlags;
677 mh32->dwOffset = mh16->dwOffset;
678 if (mh32->reserved >= sizeof(MIDIHDR))
679 mh32->dwOffset = mh16->dwOffset;
680 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
681 /* initial map is: 16 => 32 */
682 LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1);
683 SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
684 LPMIDIHDR mh16 = MapSL(segmh16);
685
686 dwParam1 = (DWORD)segmh16;
687 mh16->dwFlags = mh32->dwFlags;
688 if (mh16->reserved >= sizeof(MIDIHDR))
689 mh16->dwOffset = mh32->dwOffset;
690 }
691 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
692 break;
693 /* case MOM_POSITIONCB: */
694 default:
695 ERR("Unknown msg %u\n", uMsg);
696 }
697
698 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
699 }
700
701 /* =================================
702 * W A V E I N M A P P E R S
703 * ================================= */
704
705 /**************************************************************************
706 * MMDRV_WaveIn_Map16To32W [internal]
707 */
708 static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
709 {
710 WINMM_MapType ret = WINMM_MAP_MSGERROR;
711
712 switch (wMsg) {
713 case WIDM_GETNUMDEVS:
714 case WIDM_RESET:
715 case WIDM_START:
716 case WIDM_STOP:
717 ret = WINMM_MAP_OK;
718 break;
719 case WIDM_OPEN:
720 case WIDM_CLOSE:
721 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
722 break;
723 case WIDM_GETDEVCAPS:
724 {
725 LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW));
726 LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
727
728 if (wic32) {
729 *(LPWAVEINCAPS16*)wic32 = wic16;
730 wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
731 *lpParam1 = (DWORD)wic32;
732 *lpParam2 = sizeof(WAVEINCAPSW);
733
734 ret = WINMM_MAP_OKMEM;
735 } else {
736 ret = WINMM_MAP_NOMEM;
737 }
738 }
739 break;
740 case WIDM_GETPOS:
741 {
742 LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
743 LPMMTIME16 mmt16 = MapSL(*lpParam1);
744
745 if (mmt32) {
746 *(LPMMTIME16*)mmt32 = mmt16;
747 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
748
749 mmt32->wType = mmt16->wType;
750 *lpParam1 = (DWORD)mmt32;
751 *lpParam2 = sizeof(MMTIME);
752
753 ret = WINMM_MAP_OKMEM;
754 } else {
755 ret = WINMM_MAP_NOMEM;
756 }
757 }
758 break;
759 case WIDM_PREPARE:
760 {
761 LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
762 LPWAVEHDR wh16 = MapSL(*lpParam1);
763
764 if (wh32) {
765 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
766 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
767 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
768 wh32->dwBufferLength = wh16->dwBufferLength;
769 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
770 wh32->dwUser = wh16->dwUser;
771 wh32->dwFlags = wh16->dwFlags;
772 wh32->dwLoops = wh16->dwLoops;
773 /* FIXME: nothing on wh32->lpNext */
774 /* could link the wh32->lpNext at this level for memory house keeping */
775 wh16->lpNext = wh32; /* for reuse in unprepare and write */
776 *lpParam1 = (DWORD)wh32;
777 *lpParam2 = sizeof(WAVEHDR);
778
779 ret = WINMM_MAP_OKMEM;
780 } else {
781 ret = WINMM_MAP_NOMEM;
782 }
783 }
784 break;
785 case WIDM_ADDBUFFER:
786 case WIDM_UNPREPARE:
787 {
788 LPWAVEHDR wh16 = MapSL(*lpParam1);
789 LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext;
790
791 *lpParam1 = (DWORD)wh32;
792 *lpParam2 = sizeof(WAVEHDR);
793 /* dwBufferLength can be reduced between prepare & write */
794 if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
795 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
796 wh32->dwBufferLength, wh16->dwBufferLength);
797 } else
798 wh32->dwBufferLength = wh16->dwBufferLength;
799 ret = WINMM_MAP_OKMEM;
800 }
801 break;
802 case WIDM_MAPPER_STATUS:
803 /* just a single DWORD */
804 *lpParam2 = (DWORD)MapSL(*lpParam2);
805 ret = WINMM_MAP_OK;
806 break;
807 default:
808 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
809 break;
810 }
811 return ret;
812 }
813
814 /**************************************************************************
815 * MMDRV_WaveIn_UnMap16To32W [internal]
816 */
817 static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
818 {
819 WINMM_MapType ret = WINMM_MAP_MSGERROR;
820
821 switch (wMsg) {
822 case WIDM_GETNUMDEVS:
823 case WIDM_RESET:
824 case WIDM_START:
825 case WIDM_STOP:
826 case WIDM_MAPPER_STATUS:
827 ret = WINMM_MAP_OK;
828 break;
829 case WIDM_OPEN:
830 case WIDM_CLOSE:
831 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
832 break;
833 case WIDM_GETDEVCAPS:
834 {
835 LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1);
836 LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
837
838 wic16->wMid = wic32->wMid;
839 wic16->wPid = wic32->wPid;
840 wic16->vDriverVersion = wic32->vDriverVersion;
841 WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
842 sizeof(wic16->szPname), NULL, NULL );
843 wic16->dwFormats = wic32->dwFormats;
844 wic16->wChannels = wic32->wChannels;
845 HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
846 ret = WINMM_MAP_OK;
847 }
848 break;
849 case WIDM_GETPOS:
850 {
851 LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
852 LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
853
854 MMSYSTEM_MMTIME32to16(mmt16, mmt32);
855 HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
856 ret = WINMM_MAP_OK;
857 }
858 break;
859 case WIDM_ADDBUFFER:
860 case WIDM_PREPARE:
861 case WIDM_UNPREPARE:
862 {
863 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
864 LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
865
866 assert(wh16->lpNext == wh32);
867 wh16->dwBufferLength = wh32->dwBufferLength;
868 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
869 wh16->dwUser = wh32->dwUser;
870 wh16->dwFlags = wh32->dwFlags;
871 wh16->dwLoops = wh32->dwLoops;
872
873 if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
874 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
875 wh16->lpNext = 0;
876 }
877 ret = WINMM_MAP_OK;
878 }
879 break;
880 default:
881 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
882 break;
883 }
884 return ret;
885 }
886
887 /**************************************************************************
888 * MMDRV_WaveIn_Map32WTo16 [internal]
889 */
890 static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
891 {
892 WINMM_MapType ret = WINMM_MAP_MSGERROR;
893
894 switch (wMsg) {
895 case WIDM_CLOSE:
896 case WIDM_GETNUMDEVS:
897 case WIDM_RESET:
898 case WIDM_START:
899 case WIDM_STOP:
900 ret = WINMM_MAP_OK;
901 break;
902
903 case WIDM_OPEN:
904 {
905 LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
906 int sz = sizeof(WAVEFORMATEX);
907 LPVOID ptr;
908 LPWAVEOPENDESC16 wod16;
909
910 /* allocated data are mapped as follows:
911 LPWAVEOPENDESC ptr to orig lParam1
912 DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
913 DWORD dwUser passed to driver
914 WAVEOPENDESC16 wod16: openDesc passed to driver
915 WAVEFORMATEX openDesc->lpFormat passed to driver
916 xxx extra bytes to WAVEFORMATEX
917 */
918 if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
919 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
920 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
921 }
922
923 ptr = HeapAlloc( GetProcessHeap(), 0,
924 sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
925
926 if (ptr) {
927 SEGPTR seg_ptr = MapLS( ptr );
928 *(LPWAVEOPENDESC*)ptr = wod32;
929 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
930 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
931
932 wod16->hWave = HWAVE_16(wod32->hWave);
933 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
934 memcpy(wod16 + 1, wod32->lpFormat, sz);
935
936 wod16->dwCallback = wod32->dwCallback;
937 wod16->dwInstance = wod32->dwInstance;
938 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
939 wod16->dnDevNode = wod32->dnDevNode;
940
941 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
942 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
943
944 ret = WINMM_MAP_OKMEM;
945 } else {
946 ret = WINMM_MAP_NOMEM;
947 }
948 }
949 break;
950 case WIDM_PREPARE:
951 {
952 LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
953 LPWAVEHDR wh16;
954 LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
955 sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
956
957 if (ptr) {
958 SEGPTR seg_ptr = MapLS( ptr );
959 *(LPWAVEHDR*)ptr = wh32;
960 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
961 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
962 /* data will be copied on WODM_WRITE */
963 wh16->dwBufferLength = wh32->dwBufferLength;
964 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
965 wh16->dwUser = wh32->dwUser;
966 wh16->dwFlags = wh32->dwFlags;
967 wh16->dwLoops = wh32->dwLoops;
968 /* FIXME: nothing on wh32->lpNext */
969 /* could link the wh32->lpNext at this level for memory house keeping */
970 wh32->lpNext = wh16; /* for reuse in unprepare and write */
971 TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
972 seg_ptr + sizeof(LPWAVEHDR), wh16->lpData,
973 wh32->dwBufferLength, wh32->lpData);
974 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
975 *lpParam2 = sizeof(WAVEHDR);
976
977 ret = WINMM_MAP_OKMEM;
978 } else {
979 ret = WINMM_MAP_NOMEM;
980 }
981 }
982 break;
983 case WIDM_ADDBUFFER:
984 case WIDM_UNPREPARE:
985 {
986 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
987 LPWAVEHDR wh16 = wh32->lpNext;
988 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
989 SEGPTR seg_ptr = MapLS( ptr );
990
991 assert(*(LPWAVEHDR*)ptr == wh32);
992
993 TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
994 seg_ptr + sizeof(LPWAVEHDR), wh16->lpData, wh32->dwBufferLength, wh32->lpData);
995
996 if (wMsg == WIDM_ADDBUFFER)
997 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
998
999 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1000 *lpParam2 = sizeof(WAVEHDR);
1001 /* dwBufferLength can be reduced between prepare & write */
1002 if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
1003 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
1004 wh16->dwBufferLength, wh32->dwBufferLength);
1005 } else
1006 wh16->dwBufferLength = wh32->dwBufferLength;
1007 ret = WINMM_MAP_OKMEM;
1008 }
1009 break;
1010 case WIDM_GETDEVCAPS:
1011 {
1012 LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)*lpParam1;
1013 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSW) + sizeof(WAVEINCAPS16));
1014
1015 if (ptr) {
1016 *(LPWAVEINCAPSW*)ptr = wic32;
1017 ret = WINMM_MAP_OKMEM;
1018 } else {
1019 ret = WINMM_MAP_NOMEM;
1020 }
1021 *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSW);
1022 *lpParam2 = sizeof(WAVEINCAPS16);
1023 }
1024 break;
1025 case WIDM_GETPOS:
1026 {
1027 LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1028 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1029 LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1030
1031 if (ptr) {
1032 *(LPMMTIME*)ptr = mmt32;
1033 mmt16->wType = mmt32->wType;
1034 ret = WINMM_MAP_OKMEM;
1035 } else {
1036 ret = WINMM_MAP_NOMEM;
1037 }
1038 *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1039 *lpParam2 = sizeof(MMTIME16);
1040 }
1041 break;
1042 case DRVM_MAPPER_STATUS:
1043 {
1044 LPDWORD p32 = (LPDWORD)*lpParam2;
1045 *lpParam2 = MapLS(p32);
1046 ret = WINMM_MAP_OKMEM;
1047 }
1048 break;
1049 default:
1050 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1051 break;
1052 }
1053 return ret;
1054 }
1055
1056 /**************************************************************************
1057 * MMDRV_WaveIn_UnMap32WTo16 [internal]
1058 */
1059 static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
1060 {
1061 WINMM_MapType ret = WINMM_MAP_MSGERROR;
1062
1063 switch (wMsg) {
1064 case WIDM_CLOSE:
1065 case WIDM_GETNUMDEVS:
1066 case WIDM_RESET:
1067 case WIDM_START:
1068 case WIDM_STOP:
1069 ret = WINMM_MAP_OK;
1070 break;
1071
1072 case WIDM_OPEN:
1073 {
1074 LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
1075 LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1076 LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
1077
1078 UnMapLS( *lpParam1 );
1079 wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1080 **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1081 HeapFree( GetProcessHeap(), 0, ptr );
1082 ret = WINMM_MAP_OK;
1083 }
1084 break;
1085
1086 case WIDM_ADDBUFFER:
1087 case WIDM_PREPARE:
1088 case WIDM_UNPREPARE:
1089 {
1090 LPWAVEHDR wh16 = MapSL(*lpParam1);
1091 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1092 LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
1093
1094 assert(wh32->lpNext == wh16);
1095 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1096 wh32->dwUser = wh16->dwUser;
1097 wh32->dwFlags = wh16->dwFlags;
1098 wh32->dwLoops = wh16->dwLoops;
1099 UnMapLS( *lpParam1 );
1100
1101 if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1102 HeapFree( GetProcessHeap(), 0, ptr );
1103 wh32->lpNext = 0;
1104 }
1105 ret = WINMM_MAP_OK;
1106 }
1107 break;
1108 case WIDM_GETDEVCAPS:
1109 {
1110 LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
1111 LPSTR ptr = (LPSTR)wic16 - sizeof(LPWAVEINCAPSW);
1112 LPWAVEINCAPSW wic32 = *(LPWAVEINCAPSW*)ptr;
1113
1114 wic32->wMid = wic16->wMid;
1115 wic32->wPid = wic16->wPid;
1116 wic32->vDriverVersion = wic16->vDriverVersion;
1117 WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
1118 sizeof(wic16->szPname), NULL, NULL );
1119 wic32->dwFormats = wic16->dwFormats;
1120 wic32->wChannels = wic16->wChannels;
1121 UnMapLS( *lpParam1 );
1122 HeapFree( GetProcessHeap(), 0, ptr );
1123 ret = WINMM_MAP_OK;
1124 }
1125 break;
1126 case WIDM_GETPOS:
1127 {
1128 LPMMTIME16 mmt16 = MapSL(*lpParam1);
1129 LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
1130 LPMMTIME mmt32 = *(LPMMTIME*)ptr;
1131
1132 MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1133 UnMapLS( *lpParam1 );
1134 HeapFree( GetProcessHeap(), 0, ptr );
1135 ret = WINMM_MAP_OK;
1136 }
1137 break;
1138 case DRVM_MAPPER_STATUS:
1139 {
1140 UnMapLS( *lpParam2 );
1141 ret = WINMM_MAP_OK;
1142 }
1143 break;
1144 default:
1145 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1146 break;
1147 }
1148 return ret;
1149 }
1150
1151 /**************************************************************************
1152 * MMDRV_WaveIn_Callback [internal]
1153 */
1154 static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1155 {
1156 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
1157
1158 switch (uMsg) {
1159 case WIM_OPEN:
1160 case WIM_CLOSE:
1161 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1162 break;
1163 case WIM_DATA:
1164 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1165 /* initial map is: 32 => 16 */
1166 LPWAVEHDR wh16 = MapSL(dwParam1);
1167 LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1168
1169 dwParam1 = (DWORD)wh32;
1170 wh32->dwFlags = wh16->dwFlags;
1171 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1172 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1173 /* initial map is: 16 => 32 */
1174 LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1);
1175 SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1176 LPWAVEHDR wh16 = MapSL(segwh16);
1177
1178 dwParam1 = (DWORD)segwh16;
1179 wh16->dwFlags = wh32->dwFlags;
1180 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1181 }
1182 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1183 break;
1184 default:
1185 ERR("Unknown msg %u\n", uMsg);
1186 }
1187
1188 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1189 }
1190
1191 /* =================================
1192 * W A V E O U T M A P P E R S
1193 * ================================= */
1194
1195 /**************************************************************************
1196 * MMDRV_WaveOut_Map16To32W [internal]
1197 */
1198 static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
1199 {
1200 WINMM_MapType ret = WINMM_MAP_MSGERROR;
1201
1202 switch (wMsg) {
1203 /* nothing to do */
1204 case WODM_BREAKLOOP:
1205 case WODM_CLOSE:
1206 case WODM_GETNUMDEVS:
1207 case WODM_PAUSE:
1208 case WODM_RESET:
1209 case WODM_RESTART:
1210 case WODM_SETPITCH:
1211 case WODM_SETPLAYBACKRATE:
1212 case WODM_SETVOLUME:
1213 ret = WINMM_MAP_OK;
1214 break;
1215
1216 case WODM_GETPITCH:
1217 case WODM_GETPLAYBACKRATE:
1218 case WODM_GETVOLUME:
1219 case WODM_OPEN:
1220 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
1221 break;
1222
1223 case WODM_GETDEVCAPS:
1224 {
1225 LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW));
1226 LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
1227
1228 if (woc32) {
1229 *(LPWAVEOUTCAPS16*)woc32 = woc16;
1230 woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
1231 *lpParam1 = (DWORD)woc32;
1232 *lpParam2 = sizeof(WAVEOUTCAPSW);
1233
1234 ret = WINMM_MAP_OKMEM;
1235 } else {
1236 ret = WINMM_MAP_NOMEM;
1237 }
1238 }
1239 break;
1240 case WODM_GETPOS:
1241 {
1242 LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
1243 LPMMTIME16 mmt16 = MapSL(*lpParam1);
1244
1245 if (mmt32) {
1246 *(LPMMTIME16*)mmt32 = mmt16;
1247 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
1248
1249 mmt32->wType = mmt16->wType;
1250 *lpParam1 = (DWORD)mmt32;
1251 *lpParam2 = sizeof(MMTIME);
1252
1253 ret = WINMM_MAP_OKMEM;
1254 } else {
1255 ret = WINMM_MAP_NOMEM;
1256 }
1257 }
1258 break;
1259 case WODM_PREPARE:
1260 {
1261 LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
1262 LPWAVEHDR wh16 = MapSL(*lpParam1);
1263
1264 if (wh32) {
1265 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
1266 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
1267 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
1268 wh32->dwBufferLength = wh16->dwBufferLength;
1269 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1270 wh32->dwUser = wh16->dwUser;
1271 wh32->dwFlags = wh16->dwFlags;
1272 wh32->dwLoops = wh16->dwLoops;
1273 /* FIXME: nothing on wh32->lpNext */
1274 /* could link the wh32->lpNext at this level for memory house keeping */
1275 wh16->lpNext = wh32; /* for reuse in unprepare and write */
1276 *lpParam1 = (DWORD)wh32;
1277 *lpParam2 = sizeof(WAVEHDR);
1278
1279 ret = WINMM_MAP_OKMEM;
1280 } else {
1281 ret = WINMM_MAP_NOMEM;
1282 }
1283 }
1284 break;
1285 case WODM_UNPREPARE:
1286 case WODM_WRITE:
1287 {
1288 LPWAVEHDR wh16 = MapSL(*lpParam1);
1289 LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext;
1290
1291 *lpParam1 = (DWORD)wh32;
1292 *lpParam2 = sizeof(WAVEHDR);
1293 /* dwBufferLength can be reduced between prepare & write */
1294 if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
1295 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
1296 wh32->dwBufferLength, wh16->dwBufferLength);
1297 } else
1298 wh32->dwBufferLength = wh16->dwBufferLength;
1299 ret = WINMM_MAP_OKMEM;
1300 }
1301 break;
1302 case WODM_MAPPER_STATUS:
1303 *lpParam2 = (DWORD)MapSL(*lpParam2);
1304 ret = WINMM_MAP_OK;
1305 break;
1306 default:
1307 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1308 break;
1309 }
1310 return ret;
1311 }
1312
1313 /**************************************************************************
1314 * MMDRV_WaveOut_UnMap16To32W [internal]
1315 */
1316 static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
1317 {
1318 WINMM_MapType ret = WINMM_MAP_MSGERROR;
1319
1320 switch (wMsg) {
1321 /* nothing to do */
1322 case WODM_BREAKLOOP:
1323 case WODM_CLOSE:
1324 case WODM_GETNUMDEVS:
1325 case WODM_PAUSE:
1326 case WODM_RESET:
1327 case WODM_RESTART:
1328 case WODM_SETPITCH:
1329 case WODM_SETPLAYBACKRATE:
1330 case WODM_SETVOLUME:
1331 case WODM_MAPPER_STATUS:
1332 ret = WINMM_MAP_OK;
1333 break;
1334
1335 case WODM_GETPITCH:
1336 case WODM_GETPLAYBACKRATE:
1337 case WODM_GETVOLUME:
1338 case WODM_OPEN:
1339 FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
1340 break;
1341
1342 case WODM_GETDEVCAPS:
1343 {
1344 LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1);
1345 LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1346
1347 woc16->wMid = woc32->wMid;
1348 woc16->wPid = woc32->wPid;
1349 woc16->vDriverVersion = woc32->vDriverVersion;
1350 WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
1351 sizeof(woc16->szPname), NULL, NULL );
1352 woc16->dwFormats = woc32->dwFormats;
1353 woc16->wChannels = woc32->wChannels;
1354 woc16->dwSupport = woc32->dwSupport;
1355 HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1356 ret = WINMM_MAP_OK;
1357 }
1358 break;
1359 case WODM_GETPOS:
1360 {
1361 LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
1362 LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
1363
1364 MMSYSTEM_MMTIME32to16(mmt16, mmt32);
1365 HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
1366 ret = WINMM_MAP_OK;
1367 }
1368 break;
1369 case WODM_PREPARE:
1370 case WODM_UNPREPARE:
1371 case WODM_WRITE:
1372 {
1373 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
1374 LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
1375
1376 assert(wh16->lpNext == wh32);
1377 wh16->dwBufferLength = wh32->dwBufferLength;
1378 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1379 wh16->dwUser = wh32->dwUser;
1380 wh16->dwFlags = wh32->dwFlags;
1381 wh16->dwLoops = wh32->dwLoops;
1382
1383 if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1384 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
1385 wh16->lpNext = 0;
1386 }
1387 ret = WINMM_MAP_OK;
1388 }
1389 break;
1390 default:
1391 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1392 break;
1393 }
1394 return ret;
1395 }
1396
1397 /**************************************************************************
1398 * MMDRV_WaveOut_Map32WTo16 [internal]
1399 */
1400 static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
1401 {
1402 WINMM_MapType ret;
1403
1404 switch (wMsg) {
1405 /* nothing to do */
1406 case WODM_BREAKLOOP:
1407 case WODM_CLOSE:
1408 case WODM_GETNUMDEVS:
1409 case WODM_PAUSE:
1410 case WODM_RESET:
1411 case WODM_RESTART:
1412 case WODM_SETPITCH:
1413 case WODM_SETPLAYBACKRATE:
1414 case WODM_SETVOLUME:
1415 ret = WINMM_MAP_OK;
1416 break;
1417
1418 case WODM_GETDEVCAPS:
1419 {
1420 LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)*lpParam1;
1421 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0,
1422 sizeof(LPWAVEOUTCAPSW) + sizeof(WAVEOUTCAPS16));
1423
1424 if (ptr) {
1425 *(LPWAVEOUTCAPSW*)ptr = woc32;
1426 ret = WINMM_MAP_OKMEM;
1427 } else {
1428 ret = WINMM_MAP_NOMEM;
1429 }
1430 *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSW);
1431 *lpParam2 = sizeof(WAVEOUTCAPS16);
1432 }
1433 break;
1434 case WODM_GETPITCH:
1435 FIXME("NIY: no conversion yet\n");
1436 ret = WINMM_MAP_MSGERROR;
1437 break;
1438 case WODM_GETPLAYBACKRATE:
1439 FIXME("NIY: no conversion yet\n");
1440 ret = WINMM_MAP_MSGERROR;
1441 break;
1442 case WODM_GETPOS:
1443 {
1444 LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1445 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1446 LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1447
1448 if (ptr) {
1449 *(LPMMTIME*)ptr = mmt32;
1450 mmt16->wType = mmt32->wType;
1451 ret = WINMM_MAP_OKMEM;
1452 } else {
1453 ret = WINMM_MAP_NOMEM;
1454 }
1455 *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1456 *lpParam2 = sizeof(MMTIME16);
1457 }
1458 break;
1459 case WODM_GETVOLUME:
1460 FIXME("NIY: no conversion yet\n");
1461 ret = WINMM_MAP_MSGERROR;
1462 break;
1463 case WODM_OPEN:
1464 {
1465 LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
1466 int sz = sizeof(WAVEFORMATEX);
1467 LPVOID ptr;
1468 LPWAVEOPENDESC16 wod16;
1469
1470 /* allocated data are mapped as follows:
1471 LPWAVEOPENDESC ptr to orig lParam1
1472 DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
1473 DWORD dwUser passed to driver
1474 WAVEOPENDESC16 wod16: openDesc passed to driver
1475 WAVEFORMATEX openDesc->lpFormat passed to driver
1476 xxx extra bytes to WAVEFORMATEX
1477 */
1478 if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
1479 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
1480 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
1481 }
1482
1483 ptr = HeapAlloc( GetProcessHeap(), 0,
1484 sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
1485
1486 if (ptr) {
1487 SEGPTR seg_ptr = MapLS( ptr );
1488 *(LPWAVEOPENDESC*)ptr = wod32;
1489 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
1490 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
1491
1492 wod16->hWave = HWAVE_16(wod32->hWave);
1493 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
1494 memcpy(wod16 + 1, wod32->lpFormat, sz);
1495
1496 wod16->dwCallback = wod32->dwCallback;
1497 wod16->dwInstance = wod32->dwInstance;
1498 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
1499 wod16->dnDevNode = wod32->dnDevNode;
1500
1501 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
1502 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
1503
1504 ret = WINMM_MAP_OKMEM;
1505 } else {
1506 ret = WINMM_MAP_NOMEM;
1507 }
1508 }
1509 break;
1510 case WODM_PREPARE:
1511 {
1512 LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
1513 LPWAVEHDR wh16;
1514 LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
1515 sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
1516
1517 if (ptr) {
1518 SEGPTR seg_ptr = MapLS( ptr );
1519 *(LPWAVEHDR*)ptr = wh32;
1520 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
1521 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
1522 /* data will be copied on WODM_WRITE */
1523 wh16->dwBufferLength = wh32->dwBufferLength;
1524 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1525 wh16->dwUser = wh32->dwUser;
1526 wh16->dwFlags = wh32->dwFlags;
1527 wh16->dwLoops = wh32->dwLoops;
1528 /* FIXME: nothing on wh32->lpNext */
1529 /* could link the wh32->lpNext at this level for memory house keeping */
1530 wh32->lpNext = wh16; /* for reuse in unprepare and write */
1531 TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
1532 seg_ptr + sizeof(LPWAVEHDR), wh16->lpData,
1533 wh32->dwBufferLength, wh32->lpData);
1534 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1535 *lpParam2 = sizeof(WAVEHDR);
1536
1537 ret = WINMM_MAP_OKMEM;
1538 } else {
1539 ret = WINMM_MAP_NOMEM;
1540 }
1541 }
1542 break;
1543 case WODM_UNPREPARE:
1544 case WODM_WRITE:
1545 {
1546 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
1547 LPWAVEHDR wh16 = wh32->lpNext;
1548 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1549 SEGPTR seg_ptr = MapLS( ptr );
1550
1551 assert(*(LPWAVEHDR*)ptr == wh32);
1552
1553 TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
1554 seg_ptr + sizeof(LPWAVEHDR), wh16->lpData,
1555 wh32->dwBufferLength, wh32->lpData);
1556
1557 if (wMsg == WODM_WRITE)
1558 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
1559
1560 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1561 *lpParam2 = sizeof(WAVEHDR);
1562 /* dwBufferLength can be reduced between prepare & write */
1563 if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
1564 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
1565 wh16->dwBufferLength, wh32->dwBufferLength);
1566 } else
1567 wh16->dwBufferLength = wh32->dwBufferLength;
1568 ret = WINMM_MAP_OKMEM;
1569 }
1570 break;
1571 case DRVM_MAPPER_STATUS:
1572 {
1573 LPDWORD p32 = (LPDWORD)*lpParam2;
1574 *lpParam2 = MapLS(p32);
1575 ret = WINMM_MAP_OKMEM;
1576 }
1577 break;
1578 default:
1579 FIXME("NIY: no conversion yet\n");
1580 ret = WINMM_MAP_MSGERROR;
1581 break;
1582 }
1583 return ret;
1584 }
1585
1586 /**************************************************************************
1587 * MMDRV_WaveOut_UnMap32WTo16 [internal]
1588 */
1589 static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
1590 {
1591 WINMM_MapType ret;
1592
1593 switch (wMsg) {
1594 /* nothing to do */
1595 case WODM_BREAKLOOP:
1596 case WODM_CLOSE:
1597 case WODM_GETNUMDEVS:
1598 case WODM_PAUSE:
1599 case WODM_RESET:
1600 case WODM_RESTART:
1601 case WODM_SETPITCH:
1602 case WODM_SETPLAYBACKRATE:
1603 case WODM_SETVOLUME:
1604 ret = WINMM_MAP_OK;
1605 break;
1606
1607 case WODM_GETDEVCAPS:
1608 {
1609 LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
1610 LPSTR ptr = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSW);
1611 LPWAVEOUTCAPSW woc32 = *(LPWAVEOUTCAPSW*)ptr;
1612
1613 woc32->wMid = woc16->wMid;
1614 woc32->wPid = woc16->wPid;
1615 woc32->vDriverVersion = woc16->vDriverVersion;
1616 WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
1617 sizeof(woc16->szPname), NULL, NULL );
1618 woc32->dwFormats = woc16->dwFormats;
1619 woc32->wChannels = woc16->wChannels;
1620 woc32->dwSupport = woc16->dwSupport;
1621 UnMapLS( *lpParam1 );
1622 HeapFree( GetProcessHeap(), 0, ptr );
1623 ret = WINMM_MAP_OK;
1624 }
1625 break;
1626 case WODM_GETPITCH:
1627 FIXME("NIY: no conversion yet\n");
1628 ret = WINMM_MAP_MSGERROR;
1629 break;
1630 case WODM_GETPLAYBACKRATE:
1631 FIXME("NIY: no conversion yet\n");
1632 ret = WINMM_MAP_MSGERROR;
1633 break;
1634 case WODM_GETPOS:
1635 {
1636 LPMMTIME16 mmt16 = MapSL(*lpParam1);
1637 LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
1638 LPMMTIME mmt32 = *(LPMMTIME*)ptr;
1639
1640 MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1641 UnMapLS( *lpParam1 );
1642 HeapFree( GetProcessHeap(), 0, ptr );
1643 ret = WINMM_MAP_OK;
1644 }
1645 break;
1646 case WODM_OPEN:
1647 {
1648 LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
1649 LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1650 LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
1651
1652 wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1653 **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1654 UnMapLS( *lpParam1 );
1655 HeapFree( GetProcessHeap(), 0, ptr );
1656 ret = WINMM_MAP_OK;
1657 }
1658 break;
1659 case WODM_PREPARE:
1660 case WODM_UNPREPARE:
1661 case WODM_WRITE:
1662 {
1663 LPWAVEHDR wh16 = MapSL(*lpParam1);
1664 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1665 LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
1666
1667 assert(wh32->lpNext == wh16);
1668 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1669 wh32->dwUser = wh16->dwUser;
1670 wh32->dwFlags = wh16->dwFlags;
1671 wh32->dwLoops = wh16->dwLoops;
1672
1673 UnMapLS( *lpParam1 );
1674 if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1675 HeapFree( GetProcessHeap(), 0, ptr );
1676 wh32->lpNext = 0;
1677 }
1678 ret = WINMM_MAP_OK;
1679 }
1680 break;
1681 case WODM_GETVOLUME:
1682 FIXME("NIY: no conversion yet\n");
1683 ret = WINMM_MAP_MSGERROR;
1684 break;
1685 case DRVM_MAPPER_STATUS:
1686 {
1687 UnMapLS( *lpParam2 );
1688 ret = WINMM_MAP_OK;
1689 }
1690 break;
1691 default:
1692 FIXME("NIY: no conversion yet\n");
1693 ret = WINMM_MAP_MSGERROR;
1694 break;
1695 }
1696 return ret;
1697 }
1698
1699 /**************************************************************************
1700 * MMDRV_WaveOut_Callback [internal]
1701 */
1702 static void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1703 {
1704 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
1705
1706 switch (uMsg) {
1707 case WOM_OPEN:
1708 case WOM_CLOSE:
1709 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1710 break;
1711 case WOM_DONE:
1712 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1713 /* initial map is: 32 => 16 */
1714 LPWAVEHDR wh16 = MapSL(dwParam1);
1715 LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1716
1717 dwParam1 = (DWORD)wh32;
1718 wh32->dwFlags = wh16->dwFlags;
1719 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1720 /* initial map is: 16 => 32 */
1721 LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1);
1722 SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1723 LPWAVEHDR wh16 = MapSL(segwh16);
1724
1725 dwParam1 = (DWORD)segwh16;
1726 wh16->dwFlags = wh32->dwFlags;
1727 }
1728 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1729 break;
1730 default:
1731 ERR("Unknown msg %u\n", uMsg);
1732 }
1733
1734 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1735 }
1736
1737 /* =================================
1738 * M A P P E R S H A N D L I N G
1739 * ================================= */
1740
1741 static LRESULT MMDRV_CallMMDrvFunc16(DWORD fp16, WORD dev, WORD msg, LONG instance,
1742 LONG lp1, LONG lp2)
1743 {
1744 WORD args[8];
1745 DWORD ret;
1746
1747 args[7] = dev;
1748 args[6] = msg;
1749 args[5] = HIWORD(instance);
1750 args[4] = LOWORD(instance);
1751 args[3] = HIWORD(lp1);
1752 args[2] = LOWORD(lp1);
1753 args[1] = HIWORD(lp2);
1754 args[0] = LOWORD(lp2);
1755 WOWCallback16Ex( fp16, WCB16_PASCAL, sizeof(args), args, &ret );
1756 return LOWORD(ret);
1757 }
1758
1759 /**************************************************************************
1760 * MMDRV_GetDescription16 [internal]
1761 */
1762 static BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
1763 {
1764 OFSTRUCT ofs;
1765 HFILE hFile;
1766 WORD w;
1767 DWORD dw;
1768 BOOL ret = FALSE;
1769
1770 if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) {
1771 ERR("Can't open file %s (builtin driver ?)\n", fname);
1772 return FALSE;
1773 }
1774
1775 #define E(_x) do {TRACE _x;goto theEnd;} while(0)
1776
1777 if (_lread(hFile, &w, 2) != 2) E(("Can't read sig\n"));
1778 if (w != ('Z' * 256 + 'M')) E(("Bad sig %04x\n", w));
1779 if (_llseek(hFile, 0x3C, SEEK_SET) < 0) E(("Can't seek to ext header offset\n"));
1780 if (_lread(hFile, &dw, 4) != 4) E(("Can't read ext header offset\n"));
1781 if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %u\n", dw+0x2C));
1782 if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n"));
1783 if (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %u\n", dw));
1784 if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n"));
1785 buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
1786 if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen));
1787 buf[buflen] = '\0';
1788 ret = TRUE;
1789 TRACE("Got '%s' [%d]\n", buf, buflen);
1790 theEnd:
1791 _lclose(hFile);
1792 return ret;
1793 }
1794
1795 /******************************************************************
1796 * MMDRV_LoadMMDrvFunc16
1797 *
1798 */
1799 unsigned MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d,
1800 LPWINE_MM_DRIVER lpDrv)
1801 {
1802 WINEMM_msgFunc16 func;
1803 unsigned count = 0;
1804 char buffer[128];
1805 /*
1806 * DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver'
1807 * The beginning of the module description indicates the driver supports
1808 * waveform, auxiliary, and mixer devices. Use one of the following
1809 * device-type names, followed by a colon (:) to indicate the type of
1810 * device your driver supports. If the driver supports more than one
1811 * type of device, separate each device-type name with a comma (,).
1812 *
1813 * wave for waveform audio devices
1814 * wavemapper for wave mappers
1815 * midi for MIDI audio devices
1816 * midimapper for midi mappers
1817 * aux for auxiliary audio devices
1818 * mixer for mixer devices
1819 */
1820
1821 if (d->d.d16.hDriver16) {
1822 HMODULE16 hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16);
1823
1824 #define AA(_h,_w,_x,_y,_z) \
1825 func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
1826 if (func != NULL) \
1827 { lpDrv->parts[_w].u.fnMessage##_y = func; count++; \
1828 TRACE("Got %d bit func '%s'\n", _y, #_x); }
1829
1830 #define A(_x,_y) AA(hMod16,_x,_y,16,GetProcAddress16)
1831 A(MMDRV_AUX, auxMessage);
1832 A(MMDRV_MIXER, mxdMessage);
1833 A(MMDRV_MIDIIN, midMessage);
1834 A(MMDRV_MIDIOUT,modMessage);
1835 A(MMDRV_WAVEIN, widMessage);
1836 A(MMDRV_WAVEOUT,wodMessage);
1837 #undef A
1838 #undef AA
1839 }
1840 if (TRACE_ON(winmm)) {
1841 if (MMDRV_GetDescription16(drvName, buffer, sizeof(buffer)))
1842 TRACE("%s => %s\n", drvName, buffer);
1843 else
1844 TRACE("%s => No description\n", drvName);
1845 }
1846
1847 return count;
1848 }
1849
1850 /* =================================
1851 * M C I
1852 * ================================= */
1853
1854 #if 0
1855 /* FIXME: this code is kept for not yet implemented optimisation for an application
1856 * using the 32A MCI interface and calling a 16 bit driver.
1857 * For now, we're doing two conversions:
1858 * - 32A => 32W (in 32 bit MCI code)
1859 * - 32W => 16 in this file
1860 */
1861
1862 /*
1863 * 0000 stop
1864 * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
1865 * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
1866 * 0100
1867 * 0101
1868 * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
1869 * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
1870 * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
1871 */
1872
1873 /**************************************************************************
1874 * MCI_MsgMapper32ATo16_Create [internal]
1875 *
1876 * Helper for MCI_MapMsg32ATo16.
1877 * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
1878 * segmented pointer.
1879 * map contains a list of action to be performed for the mapping (see list
1880 * above)
1881 * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
1882 */
1883 static WINMM_MapType MCI_MsgMapper32ATo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
1884 {
1885 void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
1886 LPBYTE p16, p32;
1887
1888 if (!lp) {
1889 return WINMM_MAP_NOMEM;
1890 }
1891 p32 = (LPBYTE)(*ptr);
1892 if (keep) {
1893 *(void**)lp = *ptr;
1894 p16 = (LPBYTE)lp + sizeof(void**);
1895 *ptr = (char*)MapLS(lp) + sizeof(void**);
1896 } else {
1897 p16 = lp;
1898 *ptr = (void*)MapLS(lp);
1899 }
1900
1901 if (map == 0) {
1902 memcpy(p16, p32, size16);
1903 } else {
1904 unsigned nibble;
1905 unsigned sz;
1906
1907 while (map & 0xF) {
1908 nibble = map & 0xF;
1909 if (nibble & 0x8) {
1910 sz = (nibble & 7) + 1;
1911 memcpy(p16, p32, sz);
1912 p16 += sz;
1913 p32 += sz;
1914 size16 -= sz; /* DEBUG only */
1915 } else {
1916 switch (nibble) {
1917 case 0x1:
1918 *(LPINT16)p16 = *(LPINT)p32;
1919 p16 += sizeof(INT16);
1920 p32 += sizeof(INT);
1921 size16 -= sizeof(INT16);
1922 break;
1923 case 0x2:
1924 *(LPUINT16)p16 = *(LPUINT)p32;
1925 p16 += sizeof(UINT16);
1926 p32 += sizeof(UINT);
1927 size16 -= sizeof(UINT16);
1928 break;
1929 case 0x6:
1930 *(LPDWORD)p16 = 0;
1931 p16 += sizeof(DWORD);
1932 p32 += sizeof(DWORD);
1933 size16 -= sizeof(DWORD);
1934 break;
1935 case 0x7:
1936 *(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 );
1937 p16 += sizeof(SEGPTR);
1938 p32 += sizeof(LPSTR);
1939 size16 -= sizeof(SEGPTR);
1940 break;
1941 default:
1942 FIXME("Unknown nibble for mapping (%x)\n", nibble);
1943 }
1944 }
1945 map >>= 4;
1946 }
1947 if (size16 != 0) /* DEBUG only */
1948 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1949 }
1950 return WINMM_MAP_OKMEM;
1951 }
1952
1953 /**************************************************************************
1954 * MCI_MsgMapper32ATo16_Destroy [internal]
1955 *
1956 * Helper for MCI_UnMapMsg32ATo16.
1957 */
1958 static WINMM_MapType MCI_MsgMapper32ATo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
1959 {
1960 if (ptr) {
1961 void* msg16 = MapSL((SEGPTR)ptr);
1962 void* alloc;
1963 LPBYTE p32, p16;
1964 unsigned nibble;
1965
1966 UnMapLS( (SEGPTR)ptr );
1967 if (kept) {
1968 alloc = (char*)msg16 - sizeof(void**);
1969 p32 = *(void**)alloc;
1970 p16 = msg16;
1971
1972 if (map == 0) {
1973 memcpy(p32, p16, size16);
1974 } else {
1975 while (map & 0xF) {
1976 nibble = map & 0xF;
1977 if (nibble & 0x8) {
1978 memcpy(p32, p16, (nibble & 7) + 1);
1979 p16 += (nibble & 7) + 1;
1980 p32 += (nibble & 7) + 1;
1981 size16 -= (nibble & 7) + 1;
1982 } else {
1983 switch (nibble) {
1984 case 0x1:
1985 *(LPINT)p32 = *(LPINT16)p16;
1986 p16 += sizeof(INT16);
1987 p32 += sizeof(INT);
1988 size16 -= sizeof(INT16);
1989 break;
1990 case 0x2:
1991 *(LPUINT)p32 = *(LPUINT16)p16;
1992 p16 += sizeof(UINT16);
1993 p32 += sizeof(UINT);
1994 size16 -= sizeof(UINT16);
1995 break;
1996 case 0x6:
1997 p16 += sizeof(UINT);
1998 p32 += sizeof(UINT);
1999 size16 -= sizeof(UINT);
2000 break;
2001 case 0x7:
2002 UnMapLS( *(SEGPTR *)p16 );
2003 p16 += sizeof(SEGPTR);
2004 p32 += sizeof(char*);
2005 size16 -= sizeof(SEGPTR);
2006 break;
2007 default:
2008 FIXME("Unknown nibble for mapping (%x)\n", nibble);
2009 }
2010 }
2011 map >>= 4;
2012 }
2013 if (size16 != 0) /* DEBUG only */
2014 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2015 }
2016 } else {
2017 alloc = msg16;
2018 }
2019
2020 HeapFree( GetProcessHeap(), 0, alloc );
2021 }
2022 return WINMM_MAP_OK;
2023 }
2024
2025 /**************************************************************************
2026 * MCI_MapMsg32ATo16 [internal]
2027 *
2028 * Map a 32-A bit MCI message to a 16 bit MCI message.
2029 */
2030 static WINMM_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
2031 {
2032 int size;
2033 BOOLEAN keep = FALSE;
2034 DWORD map = 0;
2035
2036 if (*lParam == 0)
2037 return WINMM_MAP_OK;
2038
2039 /* FIXME: to add also (with seg/linear modifications to do):
2040 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2041 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2042 */
2043 switch (wMsg) {
2044 case MCI_BREAK:
2045 size = sizeof(MCI_BREAK_PARMS);
2046 break;
2047 /* case MCI_CAPTURE */
2048 case MCI_CLOSE:
2049 case MCI_CLOSE_DRIVER:
2050 case MCI_CONFIGURE:
2051 size = sizeof(MCI_GENERIC_PARMS);
2052 break;
2053 /* case MCI_COPY: */
2054 case MCI_CUE:
2055 switch (uDevType) {
2056 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
2057 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2058 default: size = sizeof(MCI_GENERIC_PARMS); break;
2059 }
2060 break;
2061 /* case MCI_CUT:*/
2062 case MCI_DELETE:
2063 switch (uDevType) {
2064 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
2065 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
2066 default: size = sizeof(MCI_GENERIC_PARMS); break;
2067 }
2068 break;
2069 /* case MCI_ESCAPE: */
2070 case MCI_FREEZE:
2071 switch (uDevType) {
2072 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
2073 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
2074 default: size = sizeof(MCI_GENERIC_PARMS); break;
2075 }
2076 break;
2077 case MCI_GETDEVCAPS:
2078 keep = TRUE;
2079 size = sizeof(MCI_GETDEVCAPS_PARMS);
2080 break;
2081 /* case MCI_INDEX: */
2082 case MCI_INFO:
2083 {
2084 LPMCI_INFO_PARMSA mip32a = (LPMCI_INFO_PARMSA)(*lParam);
2085 LPMCI_INFO_PARMS16 mip16;
2086
2087 switch (uDevType) {
2088 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
2089 default: size = sizeof(MCI_INFO_PARMS16); break;
2090 }
2091 mip16 = HeapAlloc( GetProcessHeap(), 0, size);
2092 if (mip16)
2093 {
2094 mip16->dwCallback = mip32a->dwCallback;
2095 mip16->lpstrReturn = MapLS( mip32a->lpstrReturn );
2096 mip16->dwRetSize = mip32a->dwRetSize;
2097 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
2098 ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
2099 }
2100 } else {
2101 return WINMM_MAP_NOMEM;
2102 }
2103 *lParam = MapLS(mip16);
2104 }
2105 return WINMM_MAP_OKMEM;
2106 /* case MCI_MARK: */
2107 /* case MCI_MONITOR: */
2108 case MCI_OPEN:
2109 case MCI_OPEN_DRIVER:
2110 {
2111 LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
2112 char* ptr = HeapAlloc( GetProcessHeap(), 0,
2113 sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
2114 LPMCI_OPEN_PARMS16 mop16;
2115
2116
2117 if (ptr) {
2118 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
2119 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
2120 mop16->dwCallback = mop32a->dwCallback;
2121 mop16->wDeviceID = mop32a->wDeviceID;
2122 if (dwFlags & MCI_OPEN_TYPE) {
2123 if (dwFlags & MCI_OPEN_TYPE_ID) {
2124 /* dword "transparent" value */
2125 mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType;
2126 } else {
2127 /* string */
2128 mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType );
2129 }
2130 } else {
2131 /* nuthin' */
2132 mop16->lpstrDeviceType = 0;
2133 }
2134 if (dwFlags & MCI_OPEN_ELEMENT) {
2135 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
2136 mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName;
2137 } else {
2138 mop16->lpstrElementName = MapLS( mop32a->lpstrElementName );
2139 }
2140 } else {
2141 mop16->lpstrElementName = 0;
2142 }
2143 if (dwFlags & MCI_OPEN_ALIAS) {
2144 mop16->lpstrAlias = MapLS( mop32a->lpstrAlias );
2145 } else {
2146 mop16->lpstrAlias = 0;
2147 }
2148 /* copy extended information if any...
2149 * FIXME: this may seg fault if initial structure does not contain them and
2150 * the reads after msip16 fail under LDT limits...
2151 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2152 * should not take care of extended parameters, and should be used by MCI_Open
2153 * to fetch uDevType. When, this is known, the mapping for sending the
2154 * MCI_OPEN_DRIVER shall be done depending on uDevType.
2155 */
2156 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
2157 } else {
2158 return WINMM_MAP_NOMEM;
2159 }
2160 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
2161 }
2162 return WINMM_MAP_OKMEM;
2163 /* case MCI_PASTE:*/
2164 case MCI_PAUSE:
2165 size = sizeof(MCI_GENERIC_PARMS);
2166 break;
2167 case MCI_PLAY:
2168 size = sizeof(MCI_PLAY_PARMS);
2169 break;
2170 case MCI_PUT:
2171 switch (uDevType) {
2172 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
2173 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
2174 default: size = sizeof(MCI_GENERIC_PARMS); break;
2175 }
2176 break;
2177 case MCI_REALIZE:
2178 size = sizeof(MCI_GENERIC_PARMS);
2179 break;
2180 case MCI_RECORD:
2181 switch (uDevType) {
2182 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
2183 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2184 default: size = sizeof(MCI_RECORD_PARMS); break;
2185 }
2186 break;
2187 case MCI_RESUME:
2188 size = sizeof(MCI_GENERIC_PARMS);
2189 break;
2190 case MCI_SEEK:
2191 switch (uDevType) {
2192 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2193 default: size = sizeof(MCI_SEEK_PARMS); break;
2194 }
2195 break;
2196 case MCI_SET:
2197 switch (uDevType) {
2198 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
2199 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2200 case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
2201 /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
2202 * so not doing anything should work...
2203 */
2204 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
2205 default: size = sizeof(MCI_SET_PARMS); break;
2206 }
2207 break;
2208 case MCI_SETAUDIO:
2209 switch (uDevType) {
2210 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break;
2211 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2212 default: size = sizeof(MCI_GENERIC_PARMS); break;
2213 }
2214 break;
2215 /* case MCI_SETTIMECODE:*/
2216 /* case MCI_SIGNAL:*/
2217 /* case MCI_SOUND:*/
2218 case MCI_SPIN:
2219 size = sizeof(MCI_SET_PARMS);
2220 break;
2221 case MCI_STATUS:
2222 keep = TRUE;
2223 switch (uDevType) {
2224 /* FIXME:
2225 * don't know if buffer for value is the one passed through lpstrDevice
2226 * or is provided by MCI driver.
2227 * Assuming solution 2: provided by MCI driver, so zeroing on entry
2228 */
2229 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
2230 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2231 default: size = sizeof(MCI_STATUS_PARMS); break;
2232 }
2233 break;
2234 case MCI_STEP:
2235 switch (uDevType) {
2236 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
2237 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2238 case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
2239 default: size = sizeof(MCI_GENERIC_PARMS); break;
2240 }
2241 break;
2242 case MCI_STOP:
2243 size = sizeof(MCI_SET_PARMS);
2244 break;
2245 case MCI_SYSINFO:
2246 {
2247 LPMCI_SYSINFO_PARMSA msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
2248 LPMCI_SYSINFO_PARMS16 msip16;
2249 char* ptr = HeapAlloc( GetProcessHeap(), 0,
2250 sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) );
2251
2252 if (ptr) {
2253 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
2254 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
2255
2256 msip16->dwCallback = msip32a->dwCallback;
2257 msip16->lpstrReturn = MapLS( msip32a->lpstrReturn );
2258 msip16->dwRetSize = msip32a->dwRetSize;
2259 msip16->dwNumber = msip32a->dwNumber;
2260 msip16->wDeviceType = msip32a->wDeviceType;
2261 } else {
2262 return WINMM_MAP_NOMEM;
2263 }
2264 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
2265 }
2266 return WINMM_MAP_OKMEM;
2267 /* case MCI_UNDO: */
2268 case MCI_UNFREEZE:
2269 switch (uDevType) {
2270 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
2271 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
2272 default: size = sizeof(MCI_GENERIC_PARMS); break;
2273 }
2274 break;
2275 case MCI_UPDATE:
2276 switch (uDevType) {
2277 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
2278 default: size = sizeof(MCI_GENERIC_PARMS); break;
2279 }
2280 break;
2281 case MCI_WHERE:
2282 switch (uDevType) {
2283 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
2284 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
2285 default: size = sizeof(MCI_GENERIC_PARMS); break;
2286 }
2287 break;
2288 case MCI_WINDOW:
2289 switch (uDevType) {
2290 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
2291 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
2292 default: size = sizeof(MCI_GENERIC_PARMS); break;
2293 }
2294 break;
2295 case DRV_OPEN:
2296 {
2297 LPMCI_OPEN_DRIVER_PARMSA modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
2298 LPMCI_OPEN_DRIVER_PARMS16 modp16;
2299 char *ptr = HeapAlloc( GetProcessHeap(), 0,
2300 sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
2301
2302 if (ptr) {
2303 *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
2304 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2305 modp16->wDeviceID = modp32a->wDeviceID;
2306 modp16->lpstrParams = MapLS( modp32a->lpstrParams );
2307 /* other fields are gonna be filled by the driver, don't copy them */
2308 } else {
2309 return WINMM_MAP_NOMEM;
2310 }
2311 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
2312 }
2313 return WINMM_MAP_OKMEM;
2314 case DRV_LOAD:
2315 case DRV_ENABLE:
2316 case DRV_CLOSE:
2317 case DRV_DISABLE:
2318 case DRV_FREE:
2319 case DRV_CONFIGURE:
2320 case DRV_QUERYCONFIGURE:
2321 case DRV_INSTALL:
2322 case DRV_REMOVE:
2323 case DRV_EXITSESSION:
2324 case DRV_EXITAPPLICATION:
2325 case DRV_POWER:
2326 return WINMM_MAP_OK;
2327
2328 default:
2329 FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2330 return WINMM_MAP_MSGERROR;
2331 }
2332 return MCI_MsgMapper32ATo16_Create((void**)lParam, size, map, keep);
2333 }
2334
2335 /**************************************************************************
2336 * MCI_UnMapMsg32ATo16 [internal]
2337 */
2338 static WINMM_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
2339 {
2340 int size = 0;
2341 BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
2342 DWORD map = 0;
2343
2344 switch (wMsg) {
2345 case MCI_BREAK:
2346 break;
2347 /* case MCI_CAPTURE */
2348 case MCI_CLOSE:
2349 case MCI_CLOSE_DRIVER:
2350 case MCI_CONFIGURE:
2351 break;
2352 /* case MCI_COPY: */
2353 case MCI_CUE:
2354 break;
2355 /* case MCI_CUT: */
2356 case MCI_DELETE:
2357 break;
2358 /* case MCI_ESCAPE: */
2359 case MCI_FREEZE:
2360 break;
2361 case MCI_GETDEVCAPS:
2362 kept = TRUE;
2363 size = sizeof(MCI_GETDEVCAPS_PARMS);
2364 break;
2365 /* case MCI_INDEX: */
2366 case MCI_INFO:
2367 {
2368 LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam);
2369 UnMapLS( lParam );
2370 UnMapLS( mip16->lpstrReturn );
2371 HeapFree( GetProcessHeap(), 0, mip16 );
2372 }
2373 return WINMM_MAP_OK;
2374 /* case MCI_MARK: */
2375 /* case MCI_MONITOR: */
2376 case MCI_OPEN:
2377 case MCI_OPEN_DRIVER:
2378 if (lParam) {
2379 LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam);
2380 LPMCI_OPEN_PARMSA mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
2381 UnMapLS( lParam );
2382 mop32a->wDeviceID = mop16->wDeviceID;
2383 if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
2384 UnMapLS( mop16->lpstrDeviceType );
2385 if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
2386 UnMapLS( mop16->lpstrElementName );
2387 if (dwFlags & MCI_OPEN_ALIAS)
2388 UnMapLS( mop16->lpstrAlias );
2389 HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
2390 }
2391 return WINMM_MAP_OK;
2392 /* case MCI_PASTE:*/
2393 case MCI_PAUSE:
2394 break;
2395 case MCI_PLAY:
2396 break;
2397 case MCI_PUT:
2398 break;
2399 case MCI_REALIZE:
2400 break;
2401 case MCI_RECORD:
2402 break;
2403 case MCI_RESUME:
2404 break;
2405 case MCI_SEEK:
2406 break;
2407 case MCI_SET:
2408 break;
2409 case MCI_SETAUDIO:
2410 switch (uDevType) {
2411 case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break;
2412 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2413 }
2414 break;
2415 /* case MCI_SETTIMECODE:*/
2416 /* case MCI_SIGNAL:*/
2417 /* case MCI_SOUND:*/
2418 case MCI_SPIN:
2419 break;
2420 case MCI_STATUS:
2421 kept = TRUE;
2422 switch (uDevType) {
2423 case MCI_DEVTYPE_DIGITAL_VIDEO:
2424 if (lParam) {
2425 LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
2426 LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
2427
2428 UnMapLS( lParam );
2429 if (mdsp16) {
2430 mdsp32a->dwReturn = mdsp16->dwReturn;
2431 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
2432 TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
2433 TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
2434 UnMapLS( mdsp16->lpstrDrive );
2435 }
2436 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
2437 } else {
2438 return WINMM_MAP_NOMEM;
2439 }
2440 }
2441 return WINMM_MAP_OKMEM;
2442 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2443 default: size = sizeof(MCI_STATUS_PARMS); break;
2444 }
2445 break;
2446 case MCI_STEP:
2447 break;
2448 case MCI_STOP:
2449 break;
2450 case MCI_SYSINFO:
2451 if (lParam) {
2452 LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
2453 LPMCI_SYSINFO_PARMSA msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
2454
2455 UnMapLS( lParam );
2456 if (msip16) {
2457 msip16->dwCallback = msip32a->dwCallback;
2458 UnMapLS( msip16->lpstrReturn );
2459 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
2460 } else {
2461 return WINMM_MAP_NOMEM;
2462 }
2463 }
2464 return WINMM_MAP_OKMEM;
2465 /* case MCI_UNDO: */
2466 case MCI_UNFREEZE:
2467 break;
2468 case MCI_UPDATE:
2469 break;
2470 case MCI_WHERE:
2471 switch (uDevType) {
2472 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
2473 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
2474 default: break;
2475 }
2476 break;
2477 case MCI_WINDOW:
2478 switch (uDevType) {
2479 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
2480 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
2481 default: break;
2482 }
2483 /* FIXME: see map function */
2484 break;
2485
2486 case DRV_OPEN:
2487 if (lParam) {
2488 LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
2489 LPMCI_OPEN_DRIVER_PARMSA modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2490
2491 UnMapLS( lParam );
2492 modp32a->wCustomCommandTable = modp16->wCustomCommandTable;
2493 modp32a->wType = modp16->wType;
2494 UnMapLS( modp16->lpstrParams );
2495 HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
2496 }
2497 return WINMM_MAP_OK;
2498 case DRV_LOAD:
2499 case DRV_ENABLE:
2500 case DRV_CLOSE:
2501 case DRV_DISABLE:
2502 case DRV_FREE:
2503 case DRV_CONFIGURE:
2504 case DRV_QUERYCONFIGURE:
2505 case DRV_INSTALL:
2506 case DRV_REMOVE:
2507 case DRV_EXITSESSION:
2508 case DRV_EXITAPPLICATION:
2509 case DRV_POWER:
2510 FIXME("This is a hack\n");
2511 return WINMM_MAP_OK;
2512 default:
2513 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2514 return WINMM_MAP_MSGERROR;
2515 }
2516 return MCI_MsgMapper32ATo16_Destroy((void*)lParam, size, map, kept);
2517 }
2518 #endif
2519
2520 /**************************************************************************
2521 * MCI_MapMsg16To32W [internal]
2522 */
2523 static WINMM_MapType MCI_MapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
2524 {
2525 if (*lParam == 0)
2526 return WINMM_MAP_OK;
2527 /* FIXME: to add also (with seg/linear modifications to do):
2528 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2529 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2530 */
2531 switch (wMsg) {
2532 /* case MCI_CAPTURE */
2533 case MCI_CLOSE:
2534 case MCI_CLOSE_DRIVER:
2535 case MCI_CONFIGURE:
2536 case MCI_COPY:
2537 case MCI_CUE:
2538 case MCI_CUT:
2539 case MCI_DELETE:
2540 case MCI_FREEZE:
2541 case MCI_GETDEVCAPS:
2542 /* case MCI_INDEX: */
2543 /* case MCI_MARK: */
2544 /* case MCI_MONITOR: */
2545 case MCI_PASTE:
2546 case MCI_PAUSE:
2547 case MCI_PLAY:
2548 case MCI_PUT:
2549 case MCI_REALIZE:
2550 case MCI_RECORD:
2551 case MCI_RESUME:
2552 case MCI_SEEK:
2553 case MCI_SET:
2554 /* case MCI_SETTIMECODE:*/
2555 /* case MCI_SIGNAL:*/
2556 case MCI_SPIN:
2557 case MCI_STATUS: /* FIXME: is wrong for digital video */
2558 case MCI_STEP:
2559 case MCI_STOP:
2560 /* case MCI_UNDO: */
2561 case MCI_UNFREEZE:
2562 case MCI_UPDATE:
2563 case MCI_WHERE:
2564 *lParam = (DWORD)MapSL(*lParam);
2565 return WINMM_MAP_OK;
2566 case MCI_WINDOW:
2567 /* in fact, I would also need the dwFlags... to see
2568 * which members of lParam are effectively used
2569 */
2570 *lParam = (DWORD)MapSL(*lParam);
2571 FIXME("Current mapping may be wrong\n");
2572 break;
2573 case MCI_BREAK:
2574 {
2575 LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
2576 LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
2577
2578 if (mbp32) {
2579 mbp32->dwCallback = mbp16->dwCallback;
2580 mbp32->nVirtKey = mbp16->nVirtKey;
2581 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
2582 } else {
2583 return WINMM_MAP_NOMEM;
2584 }
2585 *lParam = (DWORD)mbp32;
2586 }
2587 return WINMM_MAP_OKMEM;
2588 case MCI_ESCAPE:
2589 {
2590 LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
2591 LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
2592
2593 if (mvep32w) {
2594 mvep32w->dwCallback = mvep16->dwCallback;
2595 mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
2596 } else {
2597 return WINMM_MAP_NOMEM;
2598 }
2599 *lParam = (DWORD)mvep32w;
2600 }
2601 return WINMM_MAP_OKMEM;
2602 case MCI_INFO:
2603 {
2604 LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
2605 LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
2606
2607 /* FIXME this is wrong if device is of type
2608 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
2609 */
2610 if (mip32w) {
2611 *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
2612 mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
2613 mip32w->dwCallback = mip16->dwCallback;
2614 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
2615 mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR);
2616 } else {
2617 return WINMM_MAP_NOMEM;
2618 }
2619 *lParam = (DWORD)mip32w;
2620 }
2621 return WINMM_MAP_OKMEM;
2622 case MCI_OPEN:
2623 case MCI_OPEN_DRIVER:
2624 {
2625 LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
2626 LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
2627
2628 if (mop32w) {
2629 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
2630 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
2631 mop32w->dwCallback = mop16->dwCallback;
2632 mop32w->wDeviceID = mop16->wDeviceID;
2633 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
2634 mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
2635 else
2636 mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType;
2637 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
2638 mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
2639 else
2640 mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
2641 if( ( dwFlags & MCI_OPEN_ALIAS))
2642 mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
2643 else
2644 mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
2645 /* copy extended information if any...
2646 * FIXME: this may seg fault if initial structure does not contain them and
2647 * the reads after msip16 fail under LDT limits...
2648 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2649 * should not take care of extended parameters, and should be used by MCI_Open
2650 * to fetch uDevType. When, this is known, the mapping for sending the
2651 * MCI_OPEN_DRIVER shall be done depending on uDevType.
2652 */
2653 memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
2654 } else {
2655 return WINMM_MAP_NOMEM;
2656 }
2657 *lParam = (DWORD)mop32w;
2658 }
2659 return WINMM_MAP_OKMEM;
2660 case MCI_SYSINFO:
2661 {
2662 LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
2663 LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
2664
2665 if (msip32w) {
2666 *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
2667 msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
2668 msip32w->dwCallback = msip16->dwCallback;
2669 msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
2670 msip32w->dwRetSize = msip16->dwRetSize;
2671 msip32w->dwNumber = msip16->dwNumber;
2672 msip32w->wDeviceType = msip16->wDeviceType;
2673 } else {
2674 return WINMM_MAP_NOMEM;
2675 }
2676 *lParam = (DWORD)msip32w;
2677 }
2678 return WINMM_MAP_OKMEM;
2679 case MCI_SOUND:
2680 {
2681 LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
2682 LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
2683
2684 if (mbp32) {
2685 mbp32->dwCallback = mbp16->dwCallback;
2686 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
2687 } else {
2688 return WINMM_MAP_NOMEM;
2689 }
2690 *lParam = (DWORD)mbp32;
2691 }
2692 return WINMM_MAP_OKMEM;
2693 case DRV_LOAD:
2694 case DRV_ENABLE:
2695 case DRV_OPEN:
2696 case DRV_CLOSE:
2697 case DRV_DISABLE:
2698 case DRV_FREE:
2699 case DRV_CONFIGURE:
2700 case DRV_QUERYCONFIGURE:
2701 case DRV_INSTALL:
2702 case DRV_REMOVE:
2703 case DRV_EXITSESSION:
2704 case DRV_EXITAPPLICATION:
2705 case DRV_POWER:
2706 FIXME("This is a hack\n");
2707 return WINMM_MAP_OK;
2708 default:
2709 FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2710 }
2711 return WINMM_MAP_MSGERROR;
2712 }
2713
2714 /**************************************************************************
2715 * MCI_UnMapMsg16To32W [internal]
2716 */
2717 static WINMM_MapType MCI_UnMapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
2718 {
2719 switch (wMsg) {
2720 /* case MCI_CAPTURE */
2721 case MCI_CLOSE:
2722 case MCI_CLOSE_DRIVER:
2723 case MCI_CONFIGURE:
2724 case MCI_COPY:
2725 case MCI_CUE:
2726 case MCI_CUT:
2727 case MCI_DELETE:
2728 case MCI_FREEZE:
2729 case MCI_GETDEVCAPS:
2730 /* case MCI_INDEX: */
2731 /* case MCI_MARK: */
2732 /* case MCI_MONITOR: */
2733 case MCI_PASTE:
2734 case MCI_PAUSE:
2735 case MCI_PLAY:
2736 case MCI_PUT:
2737 case MCI_REALIZE:
2738 case MCI_RECORD:
2739 case MCI_RESUME:
2740 case MCI_SEEK:
2741 case MCI_SET:
2742 /* case MCI_SETTIMECODE:*/
2743 /* case MCI_SIGNAL:*/
2744 case MCI_SPIN:
2745 case MCI_STATUS:
2746 case MCI_STEP:
2747 case MCI_STOP:
2748 /* case MCI_UNDO: */
2749 case MCI_UNFREEZE:
2750 case MCI_UPDATE:
2751 case MCI_WHERE:
2752 return WINMM_MAP_OK;
2753
2754 case MCI_WINDOW:
2755 /* FIXME ?? see Map function */
2756 return WINMM_MAP_OK;
2757
2758 case MCI_BREAK:
2759 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2760 return WINMM_MAP_OK;
2761 case MCI_ESCAPE:
2762 if (lParam) {
2763 LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
2764 HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
2765 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2766 }
2767 return WINMM_MAP_OK;
2768 case MCI_INFO:
2769 if (lParam) {
2770 LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
2771 LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
2772
2773 WideCharToMultiByte(CP_ACP, 0,
2774 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
2775 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
2776 NULL, NULL);
2777 HeapFree(GetProcessHeap(), 0, (LPVOID)mip32w->lpstrReturn);
2778 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2779 }
2780 return WINMM_MAP_OK;
2781 case MCI_SYSINFO:
2782 if (lParam) {
2783 LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
2784 LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
2785
2786 WideCharToMultiByte(CP_ACP, 0,
2787 msip32w->lpstrReturn, msip32w->dwRetSize,
2788 MapSL(msip16->lpstrReturn), msip16->dwRetSize,
2789 NULL, NULL);
2790 HeapFree(GetProcessHeap(), 0, (LPVOID)msip32w->lpstrReturn);
2791 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2792 }
2793 return WINMM_MAP_OK;
2794 case MCI_SOUND:
2795 if (lParam) {
2796 LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
2797 HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
2798 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2799 }
2800 return WINMM_MAP_OK;
2801 case MCI_OPEN:
2802 case MCI_OPEN_DRIVER:
2803 if (lParam) {
2804 LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
2805 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
2806
2807 mop16->wDeviceID = mop32w->wDeviceID;
2808 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
2809 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
2810 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
2811 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
2812 if( ( dwFlags & MCI_OPEN_ALIAS))
2813 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
2814 if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
2815 FIXME("bad free line=%d\n", __LINE__);
2816 }
2817 return WINMM_MAP_OK;
2818 case DRV_LOAD:
2819 case DRV_ENABLE:
2820 case DRV_OPEN:
2821 case DRV_CLOSE:
2822 case DRV_DISABLE:
2823 case DRV_FREE:
2824 case DRV_CONFIGURE:
2825 case DRV_QUERYCONFIGURE:
2826 case DRV_INSTALL:
2827 case DRV_REMOVE:
2828 case DRV_EXITSESSION:
2829 case DRV_EXITAPPLICATION:
2830 case DRV_POWER:
2831 FIXME("This is a hack\n");
2832 return WINMM_MAP_OK;
2833 default:
2834 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2835 }
2836 return WINMM_MAP_MSGERROR;
2837 }
2838
2839 /*
2840 * 0000 stop
2841 * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
2842 * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
2843 * 0100
2844 * 0101
2845 * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
2846 * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
2847 * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
2848 */
2849
2850 /**************************************************************************
2851 * MCI_MsgMapper32WTo16_Create [internal]
2852 *
2853 * Helper for MCI_MapMsg32WTo16.
2854 * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
2855 * segmented pointer.
2856 * map contains a list of action to be performed for the mapping (see list
2857 * above)
2858 * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
2859 */
2860 static WINMM_MapType MCI_MsgMapper32WTo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
2861 {
2862 void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
2863 LPBYTE p16, p32;
2864
2865 if (!lp) {
2866 return WINMM_MAP_NOMEM;
2867 }
2868 p32 = (LPBYTE)(*ptr);
2869 if (keep) {
2870 *(void**)lp = *ptr;
2871 p16 = (LPBYTE)lp + sizeof(void**);
2872 *ptr = (char*)MapLS(lp) + sizeof(void**);
2873 } else {
2874 p16 = lp;
2875 *ptr = (void*)MapLS(lp);
2876 }
2877
2878 if (map == 0) {
2879 memcpy(p16, p32, size16);
2880 } else {
2881 unsigned nibble;
2882 unsigned sz;
2883
2884 while (map & 0xF) {
2885 nibble = map & 0xF;
2886 if (nibble & 0x8) {
2887 sz = (nibble & 7) + 1;
2888 memcpy(p16, p32, sz);
2889 p16 += sz;
2890 p32 += sz;
2891 size16 -= sz; /* DEBUG only */
2892 } else {
2893 switch (nibble) {
2894 case 0x1:
2895 *(LPINT16)p16 = *(LPINT)p32;
2896 p16 += sizeof(INT16);
2897 p32 += sizeof(INT);
2898 size16 -= sizeof(INT16);
2899 break;
2900 case 0x2:
2901 *(LPUINT16)p16 = *(LPUINT)p32;
2902 p16 += sizeof(UINT16);
2903 p32 += sizeof(UINT);
2904 size16 -= sizeof(UINT16);
2905 break;
2906 case 0x6:
2907 *(LPDWORD)p16 = 0;
2908 p16 += sizeof(DWORD);
2909 p32 += sizeof(DWORD);
2910 size16 -= sizeof(DWORD);
2911 break;
2912 case 0x7:
2913 *(SEGPTR *)p16 = MapLS( MCI_strdupWtoA( *(LPCWSTR *)p32 ) );
2914 p16 += sizeof(SEGPTR);
2915 p32 += sizeof(LPSTR);
2916 size16 -= sizeof(SEGPTR);
2917 break;
2918 default:
2919 FIXME("Unknown nibble for mapping (%x)\n", nibble);
2920 }
2921 }
2922 map >>= 4;
2923 }
2924 if (size16 != 0) /* DEBUG only */
2925 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2926 }
2927 return WINMM_MAP_OKMEM;
2928 }
2929
2930 /**************************************************************************
2931 * MCI_MsgMapper32WTo16_Destroy [internal]
2932 *
2933 * Helper for MCI_UnMapMsg32WTo16.
2934 */
2935 static WINMM_MapType MCI_MsgMapper32WTo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
2936 {
2937 if (ptr) {
2938 void* msg16 = MapSL((SEGPTR)ptr);
2939 void* alloc;
2940 LPBYTE p32, p16;
2941 unsigned nibble;
2942
2943 UnMapLS( (SEGPTR)ptr );
2944 if (kept) {
2945 alloc = (char*)msg16 - sizeof(void**);
2946 p32 = *(void**)alloc;
2947 p16 = msg16;
2948
2949 if (map == 0) {
2950 memcpy(p32, p16, size16);
2951 } else {
2952 while (map & 0xF) {
2953 nibble = map & 0xF;
2954 if (nibble & 0x8) {
2955 memcpy(p32, p16, (nibble & 7) + 1);
2956 p16 += (nibble & 7) + 1;
2957 p32 += (nibble & 7) + 1;
2958 size16 -= (nibble & 7) + 1;
2959 } else {
2960 switch (nibble) {
2961 case 0x1:
2962 *(LPINT)p32 = *(LPINT16)p16;
2963 p16 += sizeof(INT16);
2964 p32 += sizeof(INT);
2965 size16 -= sizeof(INT16);
2966 break;
2967 case 0x2:
2968 *(LPUINT)p32 = *(LPUINT16)p16;
2969 p16 += sizeof(UINT16);
2970 p32 += sizeof(UINT);
2971 size16 -= sizeof(UINT16);
2972 break;
2973 case 0x6:
2974 p16 += sizeof(UINT);
2975 p32 += sizeof(UINT);
2976 size16 -= sizeof(UINT);
2977 break;
2978 case 0x7:
2979 HeapFree(GetProcessHeap(), 0, MapSL(*(SEGPTR *)p16));
2980 UnMapLS( *(SEGPTR *)p16 );
2981 p16 += sizeof(SEGPTR);
2982 p32 += sizeof(char*);
2983 size16 -= sizeof(SEGPTR);
2984 break;
2985 default:
2986 FIXME("Unknown nibble for mapping (%x)\n", nibble);
2987 }
2988 }
2989 map >>= 4;
2990 }
2991 if (size16 != 0) /* DEBUG only */
2992 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2993 }
2994 } else {
2995 alloc = msg16;
2996 }
2997
2998 HeapFree( GetProcessHeap(), 0, alloc );
2999 }
3000 return WINMM_MAP_OK;
3001 }
3002
3003 /**************************************************************************
3004 * MCI_MapMsg32WTo16 [internal]
3005 *
3006 * Map a 32W bit MCI message to a 16 bit MCI message.
3007 */
3008 static WINMM_MapType MCI_MapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
3009 {
3010 int size;
3011 BOOLEAN keep = FALSE;
3012 DWORD map = 0;
3013
3014 if (*lParam == 0)
3015 return WINMM_MAP_OK;
3016
3017 /* FIXME: to add also (with seg/linear modifications to do):
3018 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
3019 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
3020 */
3021 switch (wMsg) {
3022 case MCI_BREAK:
3023 size = sizeof(MCI_BREAK_PARMS);
3024 break;
3025 /* case MCI_CAPTURE */
3026 case MCI_CLOSE:
3027 case MCI_CLOSE_DRIVER:
3028 case MCI_CONFIGURE:
3029 size = sizeof(MCI_GENERIC_PARMS);
3030 break;
3031 /* case MCI_COPY: */
3032 case MCI_CUE:
3033 switch (uDevType) {
3034 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
3035 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3036 default: size = sizeof(MCI_GENERIC_PARMS); break;
3037 }
3038 break;
3039 /* case MCI_CUT:*/
3040 case MCI_DELETE:
3041 switch (uDevType) {
3042 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
3043 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
3044 default: size = sizeof(MCI_GENERIC_PARMS); break;
3045 }
3046 break;
3047 /* case MCI_ESCAPE: */
3048 case MCI_FREEZE:
3049 switch (uDevType) {
3050 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
3051 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
3052 default: size = sizeof(MCI_GENERIC_PARMS); break;
3053 }
3054 break;
3055 case MCI_GETDEVCAPS:
3056 keep = TRUE;
3057 size = sizeof(MCI_GETDEVCAPS_PARMS);
3058 break;
3059 /* case MCI_INDEX: */
3060 case MCI_INFO:
3061 {
3062 LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)(*lParam);
3063 char* ptr;
3064 LPMCI_INFO_PARMS16 mip16;
3065
3066 switch (uDevType) {
3067 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
3068 default: size = sizeof(MCI_INFO_PARMS16); break;
3069 }
3070 ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMCI_INFO_PARMSW) + size);
3071 if (ptr)
3072 {
3073 *(LPMCI_INFO_PARMSW*)ptr = mip32w;
3074 mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSW));
3075 mip16->dwCallback = mip32w->dwCallback;
3076 mip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, mip32w->dwRetSize / sizeof(WCHAR)) );
3077 mip16->dwRetSize = mip32w->dwRetSize / sizeof(WCHAR);
3078 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
3079 ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSW)mip32w)->dwItem;
3080 }
3081 } else {
3082 return WINMM_MAP_NOMEM;
3083 }
3084 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_INFO_PARMSW);
3085 }
3086 return WINMM_MAP_OKMEM;
3087 /* case MCI_MARK: */
3088 /* case MCI_MONITOR: */
3089 case MCI_OPEN:
3090 case MCI_OPEN_DRIVER:
3091 {
3092 LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)(*lParam);
3093 char* ptr = HeapAlloc( GetProcessHeap(), 0,
3094 sizeof(LPMCI_OPEN_PARMSW) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
3095 LPMCI_OPEN_PARMS16 mop16;
3096
3097
3098 if (ptr) {
3099 *(LPMCI_OPEN_PARMSW*)(ptr) = mop32w;
3100 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSW));
3101 mop16->dwCallback = mop32w->dwCallback;
3102 mop16->wDeviceID = mop32w->wDeviceID;
3103 if (dwFlags & MCI_OPEN_TYPE) {
3104 if (dwFlags & MCI_OPEN_TYPE_ID) {
3105 /* dword "transparent" value */
3106 mop16->lpstrDeviceType = (SEGPTR)mop32w->lpstrDeviceType;
3107 } else {
3108 /* string */
3109 mop16->lpstrDeviceType = MapLS( MCI_strdupWtoA(mop32w->lpstrDeviceType) );
3110 }
3111 } else {
3112 /* nuthin' */
3113 mop16->lpstrDeviceType = 0;
3114 }
3115 if (dwFlags & MCI_OPEN_ELEMENT) {
3116 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
3117 mop16->lpstrElementName = (SEGPTR)mop32w->lpstrElementName;
3118 } else {
3119 mop16->lpstrElementName = MapLS( MCI_strdupWtoA(mop32w->lpstrElementName) );
3120 }
3121 } else {
3122 mop16->lpstrElementName = 0;
3123 }
3124 if (dwFlags & MCI_OPEN_ALIAS) {
3125 mop16->lpstrAlias = MapLS( MCI_strdupWtoA(mop32w->lpstrAlias) );
3126 } else {
3127 mop16->lpstrAlias = 0;
3128 }
3129 /* copy extended information if any...
3130 * FIXME: this may seg fault if initial structure does not contain them and
3131 * the reads after msip16 fail under LDT limits...
3132 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
3133 * should not take care of extended parameters, and should be used by MCI_Open
3134 * to fetch uDevType. When, this is known, the mapping for sending the
3135 * MCI_OPEN_DRIVER shall be done depending on uDevType.
3136 */
3137 memcpy(mop16 + 1, mop32w + 1, 2 * sizeof(DWORD));
3138 } else {
3139 return WINMM_MAP_NOMEM;
3140 }
3141 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSW);
3142 }
3143 return WINMM_MAP_OKMEM;
3144 /* case MCI_PASTE:*/
3145 case MCI_PAUSE:
3146 size = sizeof(MCI_GENERIC_PARMS);
3147 break;
3148 case MCI_PLAY:
3149 size = sizeof(MCI_PLAY_PARMS);
3150 break;
3151 case MCI_PUT:
3152 switch (uDevType) {
3153 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
3154 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
3155 default: size = sizeof(MCI_GENERIC_PARMS); break;
3156 }
3157 break;
3158 case MCI_REALIZE:
3159 size = sizeof(MCI_GENERIC_PARMS);
3160 break;
3161 case MCI_RECORD:
3162 switch (uDevType) {
3163 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
3164 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3165 default: size = sizeof(MCI_RECORD_PARMS); break;
3166 }
3167 break;
3168 case MCI_RESUME:
3169 size = sizeof(MCI_GENERIC_PARMS);
3170 break;
3171 case MCI_SEEK:
3172 switch (uDevType) {
3173 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3174 default: size = sizeof(MCI_SEEK_PARMS); break;
3175 }
3176 break;
3177 case MCI_SET:
3178 switch (uDevType) {
3179 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
3180 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3181 case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
3182 /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
3183 * so not doing anything should work...
3184 */
3185 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
3186 default: size = sizeof(MCI_SET_PARMS); break;
3187 }
3188 break;
3189 case MCI_SETAUDIO:
3190 switch (uDevType) {
3191 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break;
3192 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3193 default: size = sizeof(MCI_GENERIC_PARMS); break;
3194 }
3195 break;
3196 /* case MCI_SETTIMECODE:*/
3197 /* case MCI_SIGNAL:*/
3198 /* case MCI_SOUND:*/
3199 case MCI_SPIN:
3200 size = sizeof(MCI_SET_PARMS);
3201 break;
3202 case MCI_STATUS:
3203 keep = TRUE;
3204 switch (uDevType) {
3205 /* FIXME:
3206 * don't know if buffer for value is the one passed through lpstrDevice
3207 * or is provided by MCI driver.
3208 * Assuming solution 2: provided by MCI driver, so zeroing on entry
3209 */
3210 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
3211 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3212 default: size = sizeof(MCI_STATUS_PARMS); break;
3213 }
3214 break;
3215 case MCI_STEP:
3216 switch (uDevType) {
3217 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
3218 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3219 case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
3220 default: size = sizeof(MCI_GENERIC_PARMS); break;
3221 }
3222 break;
3223 case MCI_STOP:
3224 size = sizeof(MCI_SET_PARMS);
3225 break;
3226 case MCI_SYSINFO:
3227 {
3228 LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)(*lParam);
3229 LPMCI_SYSINFO_PARMS16 msip16;
3230 char* ptr = HeapAlloc( GetProcessHeap(), 0,
3231 sizeof(LPMCI_SYSINFO_PARMSW) + sizeof(MCI_SYSINFO_PARMS16) );
3232
3233 if (ptr) {
3234 *(LPMCI_SYSINFO_PARMSW*)(ptr) = msip32w;
3235 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSW));
3236
3237 msip16->dwCallback = msip32w->dwCallback;
3238 msip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, msip32w->dwRetSize) );
3239 msip16->dwRetSize = msip32w->dwRetSize;
3240 msip16->dwNumber = msip32w->dwNumber;
3241 msip16->wDeviceType = msip32w->wDeviceType;
3242 } else {
3243 return WINMM_MAP_NOMEM;
3244 }
3245 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSW);
3246 }
3247 return WINMM_MAP_OKMEM;
3248 /* case MCI_UNDO: */
3249 case MCI_UNFREEZE:
3250 switch (uDevType) {
3251 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
3252 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
3253 default: size = sizeof(MCI_GENERIC_PARMS); break;
3254 }
3255 break;
3256 case MCI_UPDATE:
3257 switch (uDevType) {
3258 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
3259 default: size = sizeof(MCI_GENERIC_PARMS); break;
3260 }
3261 break;
3262 case MCI_WHERE:
3263 switch (uDevType) {
3264 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
3265 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
3266 default: size = sizeof(MCI_GENERIC_PARMS); break;
3267 }
3268 break;
3269 case MCI_WINDOW:
3270 switch (uDevType) {
3271 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
3272 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
3273 default: size = sizeof(MCI_GENERIC_PARMS); break;
3274 }
3275 break;
3276 case DRV_OPEN:
3277 {
3278 LPMCI_OPEN_DRIVER_PARMSW modp32w = (LPMCI_OPEN_DRIVER_PARMSW)(*lParam);
3279 LPMCI_OPEN_DRIVER_PARMS16 modp16;
3280 char *ptr = HeapAlloc( GetProcessHeap(), 0,
3281 sizeof(LPMCI_OPEN_DRIVER_PARMSW) + sizeof(MCI_OPEN_DRIVER_PARMS16));
3282
3283 if (ptr) {
3284 *(LPMCI_OPEN_DRIVER_PARMSW*)(ptr) = modp32w;
3285 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSW));
3286 modp16->wDeviceID = modp32w->wDeviceID;
3287 modp16->lpstrParams = MapLS( MCI_strdupWtoA(modp32w->lpstrParams) );
3288 /* other fields are gonna be filled by the driver, don't copy them */
3289 } else {
3290 return WINMM_MAP_NOMEM;
3291 }
3292 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSW);
3293 }
3294 return WINMM_MAP_OKMEM;
3295 case DRV_LOAD:
3296 case DRV_ENABLE:
3297 case DRV_CLOSE:
3298 case DRV_DISABLE:
3299 case DRV_FREE:
3300 case DRV_CONFIGURE:
3301 case DRV_QUERYCONFIGURE:
3302 case DRV_INSTALL:
3303 case DRV_REMOVE:
3304 case DRV_EXITSESSION:
3305 case DRV_EXITAPPLICATION:
3306 case DRV_POWER:
3307 return WINMM_MAP_OK;
3308
3309 default:
3310 FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
3311 return WINMM_MAP_MSGERROR;
3312 }
3313 return MCI_MsgMapper32WTo16_Create((void**)lParam, size, map, keep);
3314 }
3315
3316 /**************************************************************************
3317 * MCI_UnMapMsg32WTo16 [internal]
3318 */
3319 static WINMM_MapType MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
3320 {
3321 int size = 0;
3322 BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
3323 DWORD map = 0;
3324
3325 switch (wMsg) {
3326 case MCI_BREAK:
3327 break;
3328 /* case MCI_CAPTURE */
3329 case MCI_CLOSE:
3330 case MCI_CLOSE_DRIVER:
3331 case MCI_CONFIGURE:
3332 break;
3333 /* case MCI_COPY: */
3334 case MCI_CUE:
3335 break;
3336 /* case MCI_CUT: */
3337 case MCI_DELETE:
3338 break;
3339 /* case MCI_ESCAPE: */
3340 case MCI_FREEZE:
3341 break;
3342 case MCI_GETDEVCAPS:
3343 kept = TRUE;
3344 size = sizeof(MCI_GETDEVCAPS_PARMS);
3345 break;
3346 /* case MCI_INDEX: */
3347 case MCI_INFO:
3348 if (lParam) {
3349 LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam);
3350 LPMCI_INFO_PARMSW mip32w = *(LPMCI_INFO_PARMSW*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSW));
3351
3352 MultiByteToWideChar(CP_ACP, 0, MapSL(mip16->lpstrReturn), mip16->dwRetSize,
3353 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR));
3354 UnMapLS( lParam );
3355 UnMapLS( mip16->lpstrReturn );
3356 HeapFree( GetProcessHeap(), 0, (void*)MapSL(mip16->lpstrReturn) );
3357 HeapFree( GetProcessHeap(), 0, (char*)mip16 - sizeof(LPMCI_OPEN_PARMSW) );
3358 }
3359 return WINMM_MAP_OK;
3360 /* case MCI_MARK: */
3361 /* case MCI_MONITOR: */
3362 case MCI_OPEN:
3363 case MCI_OPEN_DRIVER:
3364 if (lParam) {
3365 LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam);
3366 LPMCI_OPEN_PARMSW mop32w = *(LPMCI_OPEN_PARMSW*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSW));
3367 UnMapLS( lParam );
3368 mop32w->wDeviceID = mop16->wDeviceID;
3369 if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
3370 {
3371 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrDeviceType));
3372 UnMapLS( mop16->lpstrDeviceType );
3373 }
3374 if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
3375 {
3376 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrElementName));
3377 UnMapLS( mop16->lpstrElementName );
3378 }
3379 if (dwFlags & MCI_OPEN_ALIAS)
3380 {
3381 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrAlias));
3382 UnMapLS( mop16->lpstrAlias );
3383 }
3384 HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSW) );
3385 }
3386 return WINMM_MAP_OK;
3387 /* case MCI_PASTE:*/
3388 case MCI_PAUSE:
3389 break;
3390 case MCI_PLAY:
3391 break;
3392 case MCI_PUT:
3393 break;
3394 case MCI_REALIZE:
3395 break;
3396 case MCI_RECORD:
3397 break;
3398 case MCI_RESUME:
3399 break;
3400 case MCI_SEEK:
3401 break;
3402 case MCI_SET:
3403 break;
3404 case MCI_SETAUDIO:
3405 switch (uDevType) {
3406 case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break;
3407 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3408 }
3409 break;
3410 /* case MCI_SETTIMECODE:*/
3411 /* case MCI_SIGNAL:*/
3412 /* case MCI_SOUND:*/
3413 case MCI_SPIN:
3414 break;
3415 case MCI_STATUS:
3416 kept = TRUE;
3417 switch (uDevType) {
3418 case MCI_DEVTYPE_DIGITAL_VIDEO:
3419 if (lParam) {
3420 LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
3421 LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
3422
3423 UnMapLS( lParam );
3424 if (mdsp16) {
3425 mdsp32a->dwReturn = mdsp16->dwReturn;
3426 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
3427 TRACE("MCI_STATUS (DGV) lpstrDrive=%08x\n", mdsp16->lpstrDrive);
3428 TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
3429 UnMapLS( mdsp16->lpstrDrive );
3430 }
3431 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
3432 } else {
3433 return WINMM_MAP_NOMEM;
3434 }
3435 }
3436 return WINMM_MAP_OKMEM;
3437 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
3438 default: size = sizeof(MCI_STATUS_PARMS); break;
3439 }
3440 break;
3441 case MCI_STEP:
3442 break;
3443 case MCI_STOP:
3444 break;
3445 case MCI_SYSINFO:
3446 if (lParam) {
3447 LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
3448 LPMCI_SYSINFO_PARMSW msip32w = *(LPMCI_SYSINFO_PARMSW*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW));
3449
3450 UnMapLS( lParam );
3451 if (msip16) {
3452 MultiByteToWideChar(CP_ACP, 0, MapSL(msip16->lpstrReturn), msip16->dwRetSize,
3453 msip32w->lpstrReturn, msip32w->dwRetSize/sizeof(WCHAR));
3454 UnMapLS( msip16->lpstrReturn );
3455 HeapFree( GetProcessHeap(), 0, MapSL(msip16->lpstrReturn) );
3456 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW) );
3457 } else {
3458 return WINMM_MAP_NOMEM;
3459 }
3460 }
3461 return WINMM_MAP_OKMEM;
3462 /* case MCI_UNDO: */
3463 case MCI_UNFREEZE:
3464 break;
3465 case MCI_UPDATE:
3466 break;
3467 case MCI_WHERE:
3468 switch (uDevType) {
3469 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
3470 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
3471 default: break;
3472 }
3473 break;
3474 case MCI_WINDOW:
3475 switch (uDevType) {
3476 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
3477 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
3478 default: break;
3479 }
3480 /* FIXME: see map function */
3481 break;
3482 case DRV_OPEN:
3483 if (lParam) {
3484 LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
3485 LPMCI_OPEN_DRIVER_PARMSW modp32w = *(LPMCI_OPEN_DRIVER_PARMSW*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW));
3486
3487 UnMapLS( lParam );
3488 modp32w->wCustomCommandTable = modp16->wCustomCommandTable;
3489 modp32w->wType = modp16->wType;
3490 HeapFree(GetProcessHeap(), 0, MapSL(modp16->lpstrParams));
3491 UnMapLS( modp16->lpstrParams );
3492 HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW) );
3493 }
3494 return WINMM_MAP_OK;
3495 case DRV_LOAD:
3496 case DRV_ENABLE:
3497 case DRV_CLOSE:
3498 case DRV_DISABLE:
3499 case DRV_FREE:
3500 case DRV_CONFIGURE:
3501 case DRV_QUERYCONFIGURE:
3502 case DRV_INSTALL:
3503 case DRV_REMOVE:
3504 case DRV_EXITSESSION:
3505 case DRV_EXITAPPLICATION:
3506 case DRV_POWER:
3507 FIXME("This is a hack\n");
3508 return WINMM_MAP_OK;
3509
3510 default:
3511 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
3512 return WINMM_MAP_MSGERROR;
3513 }
3514 return MCI_MsgMapper32WTo16_Destroy((void*)lParam, size, map, kept);
3515 }
3516
3517 void MMDRV_Init16(void)
3518 {
3519 #define A(_x,_y) MMDRV_InstallMap(_x, \
3520 MMDRV_##_y##_Map16To32W, MMDRV_##_y##_UnMap16To32W, \
3521 MMDRV_##_y##_Map32WTo16, MMDRV_##_y##_UnMap32WTo16, \
3522 MMDRV_##_y##_Callback)
3523 A(MMDRV_AUX, Aux);
3524 A(MMDRV_MIXER, Mixer);
3525 A(MMDRV_MIDIIN, MidiIn);
3526 A(MMDRV_MIDIOUT, MidiOut);
3527 A(MMDRV_WAVEIN, WaveIn);
3528 A(MMDRV_WAVEOUT, WaveOut);
3529 #undef A
3530
3531 pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
3532 pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
3533
3534 pFnMciMapMsg16To32W = MCI_MapMsg16To32W;
3535 pFnMciUnMapMsg16To32W = MCI_UnMapMsg16To32W;
3536 pFnMciMapMsg32WTo16 = MCI_MapMsg32WTo16;
3537 pFnMciUnMapMsg32WTo16 = MCI_UnMapMsg32WTo16;
3538 }
Maarten's multimedia branch