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